@woosh/meep-engine 3.14.2 → 3.14.3

package/src/shade/renderer/volumetrics/taa/shader_volumetrics_taa.js

@@ -1,335 +1,135 @@
-import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
-import { chunk_color_clip_to_aabb4 } from "../../postprocess/taa/chunk_color_clip_to_aabb3.js";
-import { chunk_rgb_to_YCoCg } from "../../shader/chunk/color/YCoCg/chunk_rgb_to_YCoCg.js";
-import { chunk_YCoCg_to_rgb } from "../../shader/chunk/color/YCoCg/chunk_YCoCg_to_rgb.js";
-import { chunk_aabb4_normalized_dist } from "../../shader/chunk/geometry/aabb3/chunk_aabb4_normalized_dist.js";
-import { chunk_frustum_sample_point } from "../../shader/chunk/geometry/frustum/chunk_frustum_sample_point.js";
-import { chunk_filter_blackman_harris229 } from "../../shader/chunk/filter/chunk_filter_blackman_harris229.js";
-import { chunk_ndc_to_uv } from "../../shader/chunk/texture/chunk_ndc_to_uv.js";
-import { chunk_texel_coordinate_to_uv } from "../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { chunk_cluster_depth_from_z_slice } from "../../light/cluster/chunk_cluster_depth_from_z_slice.js";
-import { chunk_cluster_depth_to_z_slice } from "../../light/cluster/chunk_cluster_depth_to_z_slice.js";
-import { VOLUMETRICS_METADATA_STRUCT } from "../VOLUMETRICS_METADATA_STRUCT.js";
-import { chunk_volumetric_history_bounding_box } from "./chunk_volumetric_history_bounding_box.js";
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addTexture("t_current", "float", "3d")
-    .addTexture("t_history", "float", "3d")
-    .addStorageTexture("t_output", "rgba16float", "3d", "write-only")
-    .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
-    .addUniform("camera_current", CAMERA_UNIFORM_STRUCT)
-    .addUniform("camera_previous", CAMERA_UNIFORM_STRUCT)
-;
-
-/**
- * 3D Blackman-Harris resample. The per-tap weight W(x) = exp(-2.29 * x * x) is provided by
- * chunk_filter_blackman_harris229 (filter_blackman_harris229). Weights precomputed for offsets -1, 0, 1.
- */
-const chunk_texture_sample_blackman_harris_3d = CodeChunk.from(
-    //language=WGSL
-    `
-fn texture_sample_blackman_harris_3d(
-    tInput: texture_3d<f32>, 
-    uvw: vec3f, 
-    tex_dim: vec3f
-) -> vec4f {
-    let sample_pos = uvw * tex_dim;
-    let center_pos = floor(sample_pos - 0.5) + 0.5;
-    let f = sample_pos - center_pos; // Fractional offset from center texel [-0.5, 0.5]
-
-    var color_sum = vec4f(0.0);
-    var weight_sum = 0.0;
-    
-    // precompute weights for offsets -1, 0, 1
-    // slignly higher register pressure, but cheaper on compute
-    let weights = mat3x3<f32>(
-        filter_blackman_harris229(-1.0 - f.x), filter_blackman_harris229(0.0 - f.x), filter_blackman_harris229(1.0 - f.x),
-        filter_blackman_harris229(-1.0 - f.y), filter_blackman_harris229(0.0 - f.y), filter_blackman_harris229(1.0 - f.y),
-        filter_blackman_harris229(-1.0 - f.z), filter_blackman_harris229(0.0 - f.z), filter_blackman_harris229(1.0 - f.z),
-    );
-    
-    // 3x3x3 Loop
-    // We iterate neighbor offsets -1, 0, 1
-    for (var z = 0; z < 3; z += 1) {
-        let wz = weights[2][z];
-        
-        for (var y = 0; y < 3; y += 1) {
-            let wy = weights[1][y];
-            
-            for (var x = 0; x < 3; x += 1) {
-                let wx = weights[0][x];
-                
-                let w = wx * wy * wz;
-                
-                let sample_offset = vec3(x - 1, y - 1, z - 1);
-                
-                let coord = vec3i(center_pos) + sample_offset;
-                
-                let coord_clamped = clamp(coord, vec3i(0), vec3i(tex_dim) - 1);
-                
-                // Boundary check (optional if texture is clamped, but good for compute)
-                // Assuming texture is clamped to edge or handled by logic
-                let texel = textureLoad(tInput, coord_clamped, 0);
-                
-                color_sum += texel * w;
-                weight_sum += w;
-            }
-        }
-    }
-    
-    // Normalize
-    return max(vec4f(0.0), color_sum / max(weight_sum, 1e-5));
-}
-    `,
-    [chunk_filter_blackman_harris229]
-);
-
-/**
- * Froxel coordinate -> a sample point for `frustum_sample_point`, NOT a froxel texture coordinate.
- *
- * That distinction is the whole reason this is not `volumetrics_position_world_to_froxel_uvw`
- * turned around. There `w` is slice space -- `log2(fma(depth, x, y)) * z`, corrected by the
- * cell-averaged content offset -- because it addresses the 3D texture. Here `w` is a LINEAR
- * fraction of the near..far range, because its only consumer is `frustum_sample_point`, which
- * mixes the near and far planes linearly. The two agree at the endpoints and nowhere between, so
- * feeding this `w` to a froxel textureSample reads the wrong slab.
- *
- * @see volumetrics_position_world_to_froxel_uvw
- * @type {CodeChunk}
- */
-const chunk_volumetrics_froxel_coord_to_frustum_uvw = CodeChunk.from(
-    //language=WGSL
-    `
-fn volumetrics_froxel_coord_to_frustum_uvw(
-    coord: vec3<u32>,
-    res: vec3<u32>,
-    camera: ${CAMERA_UNIFORM_STRUCT.wgsl_ref},
-    cluster_params: vec3f
-) -> vec3f {
-    let uv = texel_coordinate_to_uv(vec2f(coord.xy), res.xy);
-
-    // Logical near/far (clip_near_far), NOT the projection-derived range: the projection is
-    // infinite-far reverse-Z so its far resolves to ~3.4e38, which collapses z0_norm below to ~0
-    // (every slice maps to the near plane). This was the core reason TAA reprojection produced
-    // garbage. Matches the participating-media build shader.
-    let near_far = camera.clip_near_far;
-
-    let depth_raw = cluster_depth_from_z_slice(
-        f32(coord.z) + 0.5,
-        cluster_params,
-        f32(res.z)
-    );
-
-    // Use center of voxel
-    let view_depth = clamp(
-        depth_raw,
-        near_far.x,
-        near_far.y
-    );
-    
-    let z0_norm = (view_depth - near_far.x) / (near_far.y - near_far.x);
-            
-    return vec3f(uv, z0_norm);
-}    
-    `, [
-        chunk_texel_coordinate_to_uv,
-        chunk_cluster_depth_from_z_slice,
-    ]
-)
-
-const chunk_world_pos_from_froxel = CodeChunk.from(
-    //language=WGSL
-    `
-// Helper to get world position from voxel index
-fn world_pos_from_froxel(
-    coord: vec3<u32>,
-    res: vec3<u32>,
-    camera: ${CAMERA_UNIFORM_STRUCT.wgsl_ref},
-    cluster_params: vec3f,
-    frustum: array<vec4<f32>, 6>
-) -> vec3f {
-    let uvw = volumetrics_froxel_coord_to_frustum_uvw(coord, res, camera, cluster_params);
-
-    // Reconstruct the froxel-centre world position. frustum_sample_point intersects the
-    // interpolated L/R, B/T, N/F planes; X maps left->left and Z maps near->far directly, so only
-    // screen-Y is flipped vs world-Y (1.0 - uvw.y). The caller passes the metadata frustum, which
-    // carries a FINITE far plane — the camera's own projection is infinite-far reverse-Z (far plane
-    // zeroed), which frustum_sample_point cannot intersect. Mirrors the participating-media build
-    // shader's Y-only flip; replaces the old vec3(1.0) - uvw inside-out hack that mirrored X and Z.
-    return frustum_sample_point(frustum, vec3f(uvw.x, 1.0 - uvw.y, uvw.z));
-}
-`, [
-        chunk_volumetrics_froxel_coord_to_frustum_uvw,
-        chunk_frustum_sample_point,
-    ]);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(8, 8, 4)
-fn main(@builtin(global_invocation_id) voxel_id: vec3<u32>) {
-
-    let resolution = textureDimensions(t_output);
-
-    if (any(voxel_id >= resolution)) {
-        return;
-    }
-
-    // 1. Current Color
-    let color_curr = textureLoad(t_current, voxel_id, 0);
-    let rgb_curr = color_curr.rgb;
-    let center_ycocg = rgb_to_YCoCg(rgb_curr);
-    let center_encoded = vec4(center_ycocg, color_curr.a);
-
-    // 2. Reprojection
-    let current_position_ws = world_pos_from_froxel(
-        voxel_id,
-        resolution,
-        camera_current,
-        volumetrics_metadata.froxel_cluster_parameters,
-        volumetrics_metadata.frustum
-    );
-    
-    // FIX: Calculate View Space explicitly to get the correct Depth metric (-View.z)
-    let prev_view = camera_previous.view_matrix * vec4f(current_position_ws, 1.0);
-    let prev_depth = -prev_view.z; // Ensure this is Positive
-    
-    let prev_clip = camera_previous.view_projection_matrix * vec4f(current_position_ws, 1.0);
-    let prev_ndc = prev_clip.xyz / prev_clip.w;
-
-    // Standard NDC to UV
-    let prev_uv = ndc_to_uv(prev_ndc.xy);
-
-    // Linear Depth to Slice
-    let prev_slice = cluster_depth_to_z_slice(
-        prev_depth,
-        volumetrics_metadata.froxel_cluster_parameters,
-        f32(resolution.z)
-    );
-
-    // prev_slice already lands at the reconstructed froxel's CENTRE — the reconstruction sampled
-    // cluster_depth_from_z_slice(voxel.z + 0.5), so for a static camera prev_slice == voxel.z + 0.5,
-    // whose texel-centre normalized coord is exactly prev_slice / res.z. Adding a further +0.5 here
-    // double-counted the texel-centre offset and sampled half a froxel too far in Z every frame: the
-    // history blurred slice z into z+1 and the 0.95 blend fed that error back (the visible noise).
-    let prev_w = prev_slice / f32(resolution.z);
-    let prev_uvw = vec3f(prev_uv, prev_w);
-    let current_uvw = (vec3f(voxel_id) + 0.5) / vec3f(resolution);   
-
-    // 3. Validity Check — reprojection must land inside the volume, and history must not be flagged
-    // for reset (first frame / resize / teleport); otherwise we fall back to the fresh sample.
-    let is_valid = all(prev_uvw >= vec3f(0.0))
-        && all(prev_uvw <= vec3f(1.0))
-        && volumetrics_metadata.history_reset == 0u;
-    
-    // How far the voxels have moved? Distances are measured in voxels
-    let velocity_voxels = (current_uvw - prev_uvw) * vec3f(resolution);
-
-    // beyond this distance in voxels - we consider history to be invalid
-    const TAA_VELOCITY_LIMIT_IN_VOXELS_XYZ = 16.0;
-    
-    // lower confidence in history when velocity is high
-    var velocity_confidence = saturate( 1.0 - length(velocity_voxels) / TAA_VELOCITY_LIMIT_IN_VOXELS_XYZ);
-
-
-    var final_color: vec4f;
-
-    if (!is_valid) {
-        final_color = color_curr;
-    } else {
-        // 5. Sample History using Blackman-Harris Filter
-        let history_raw = texture_sample_blackman_harris_3d(
-            t_history,
-            prev_uvw,
-            vec3f(resolution)
-        );
-
-        // 6. Clip History to Neighborhood
-        let history_ycocg = rgb_to_YCoCg(history_raw.rgb);
-        let history_encoded = vec4(history_ycocg, history_raw.a);
-
-        // 4. Neighborhood Clamping (Variance Based)
-        var aabb_min: vec4f;
-        var aabb_max: vec4f;
-        
-        // Gamma: 1.0 is standard, lower = less ghosting/more flicker
-        let variance_gamma = mix(
-            vec4(0.3, 0.5, 0.5, 0.3),
-            vec4(2.5, 3, 3, 2.5),
-            velocity_confidence * velocity_confidence
-        );
-    
-        volumetric_history_bounding_box(
-            t_current,
-            center_encoded,
-            voxel_id,
-            resolution,
-            variance_gamma, 
-            &aabb_min,
-            &aabb_max
-        );
-    
-
-        let history_clamped = color_clip_to_aabb4(
-            history_encoded, 
-            center_encoded,
-            aabb_min,
-            aabb_max
-        );
-        
-        
-        // We detect when clamp would occur and dampen the incoming sample's contribution to counteract it. 
-        // see "High Quality Temporal Supersampling" by Brian Karis, EpicGames SIGGRAPH 2014
-        let t_clamp = saturate(aabb4_normalized_dist_from_center(
-            center_encoded,
-            history_clamped,
-            aabb_min,
-            aabb_max,
-        ));
-        
-        // TODO take extinction into account for clamping, currently we only do scattering
-        
-        
-        // 7. Blend
-        const blend_base = 0.95;
-
-        var confidence = 1.0;
-                
-        // Detect clamping events, so we can reduce confidence in the blend
-        let confidence_factor = mix(1.0, 0.0, t_clamp * t_clamp * t_clamp);
-
-        confidence *= confidence_factor;
-        
-        let blend = blend_base * confidence;
-
-        let mixed = mix(center_encoded, history_clamped, blend);
-
-        final_color = vec4f(YCoCg_to_rgb(mixed.xyz), mixed.w);
-        
-    }
-                    
-    textureStore(t_output, voxel_id, final_color);
-}
-    `,
-    [
-        chunk_cluster_depth_to_z_slice,
-        chunk_rgb_to_YCoCg,
-        chunk_YCoCg_to_rgb,
-        chunk_color_clip_to_aabb4,
-        chunk_texture_sample_blackman_harris_3d,
-        chunk_world_pos_from_froxel,
-        chunk_ndc_to_uv,
-        chunk_volumetric_history_bounding_box,
-        chunk_aabb4_normalized_dist,
-    ]
-);
-
-export const shader_volumetrics_taa = ComputeShader.from({
-    label: "Volumetric TAA",
-    resources,
-    body
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_rgb_to_YCoCg } from "../../shader/chunk/color/YCoCg/chunk_rgb_to_YCoCg.js";
+import { chunk_YCoCg_to_rgb } from "../../shader/chunk/color/YCoCg/chunk_YCoCg_to_rgb.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 { VOLUMETRICS_METADATA_STRUCT } from "../VOLUMETRICS_METADATA_STRUCT.js";
+import { chunk_volumetric_history_bounding_box } from "./chunk_volumetric_history_bounding_box.js";
+import { chunk_volumetrics_taa_reproject } from "./chunk_volumetrics_taa_reproject.js";
+import { chunk_volumetrics_taa_resolve } from "./chunk_volumetrics_taa_resolve.js";
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addTexture("t_current", "float", "3d")
+    .addTexture("t_history", "float", "3d")
+    // Trilinear, clamp to edge. The declared descriptor binds itself, so the graph pass passes
+    // nothing for it. The same descriptor the lighting and LUT passes sample their volumes with.
+    .addSampler("s_history", "filtering", SAMPLER_LINEAR_UPSCALE)
+    .addStorageTexture("t_output", "rgba16float", "3d", "write-only")
+    .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
+    .addUniform("camera_current", CAMERA_UNIFORM_STRUCT)
+    .addUniform("camera_previous", CAMERA_UNIFORM_STRUCT)
+;
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(8, 8, 4)
+fn main(@builtin(global_invocation_id) voxel_id: vec3<u32>) {
+
+    let resolution = textureDimensions(t_output);
+
+    if (any(voxel_id >= resolution)) {
+        return;
+    }
+
+    // 1. Current Color
+    let color_curr = textureLoad(t_current, voxel_id, 0);
+    let rgb_curr = color_curr.rgb;
+    let center_ycocg = rgb_to_YCoCg(rgb_curr);
+    let center_encoded = vec4(center_ycocg, color_curr.a);
+
+    // 2. Reprojection: where this froxel was in last frame's grid, and its depth in that camera
+    let reprojection = volumetrics_taa_reproject(
+        voxel_id,
+        resolution,
+        camera_current,
+        camera_previous,
+        volumetrics_metadata.froxel_cluster_parameters,
+        volumetrics_metadata.frustum
+    );
+
+    let prev_uvw = reprojection.xyz;
+    let current_uvw = (vec3f(voxel_id) + 0.5) / vec3f(resolution);
+
+    // 3. Validity Check
+    let is_valid = volumetrics_taa_history_valid(reprojection, volumetrics_metadata.history_reset);
+
+    // 4. How far the froxel moved between the frames, in voxels of the grid
+    let velocity_voxels = (current_uvw - prev_uvw) * vec3f(resolution);
+
+    // At this speed and beyond the neighbourhood box is at its tightest gamma. The history is NOT
+    // rejected for speed: the resampled history is still the best estimate of the froxel, and the
+    // clip below keeps it inside what the neighbourhood allows.
+    const TAA_VELOCITY_LIMIT_IN_VOXELS_XYZ = 16.0;
+
+    let velocity_confidence = saturate( 1.0 - length(velocity_voxels) / TAA_VELOCITY_LIMIT_IN_VOXELS_XYZ);
+
+
+    var final_color: vec4f;
+
+    if (!is_valid) {
+        final_color = color_curr;
+    } else {
+        // 5. Fetch the history. Trilinear, because the fetch must be interpolating: a static
+        // camera lands exactly on a texel centre and must read back exactly that texel. The 3x3x3
+        // Blackman-Harris resample this replaced weighted the +-1 neighbours at 8.4% each even at
+        // a zero offset, so every frame convolved the accumulation with a 27-tap blur and the 0.95
+        // feedback compounded it to ~1.8 froxels of sigma along each axis. Karis uses that kernel
+        // to filter the CURRENT frame; history is fetched with an interpolating filter, Catmull-Rom
+        // in his and in this repo's 2D TAA. The max guards the clip: a box corner in YCoCg need not
+        // be a non-negative RGB, and that goes into next frame's history.
+        let history_raw = max(vec4f(0.0), textureSampleLevel(t_history, s_history, prev_uvw, 0.0));
+
+        // encoded the way the centre is: YCoCg scattering, extinction as is
+        let history_ycocg = rgb_to_YCoCg(history_raw.rgb);
+        let history_encoded = vec4(history_ycocg, history_raw.a);
+
+        // 6. Neighbourhood box, variance based, always containing the centre
+        var aabb_min: vec4f;
+        var aabb_max: vec4f;
+
+        // Gamma: 1.0 is standard, lower = less ghosting/more flicker
+        let variance_gamma = mix(
+            vec4(0.3, 0.5, 0.5, 0.3),
+            vec4(2.5, 3, 3, 2.5),
+            velocity_confidence * velocity_confidence
+        );
+    
+        volumetric_history_bounding_box(
+            t_current,
+            center_encoded,
+            voxel_id,
+            resolution,
+            variance_gamma, 
+            &aabb_min,
+            &aabb_max
+        );
+    
+
+        // 7. Clip the history to the neighbourhood and blend
+        let mixed = volumetrics_taa_resolve(center_encoded, history_encoded, aabb_min, aabb_max);
+
+        final_color = vec4f(YCoCg_to_rgb(mixed.xyz), mixed.w);
+        
+    }
+                    
+    textureStore(t_output, voxel_id, final_color);
+}
+    `,
+    [
+        chunk_rgb_to_YCoCg,
+        chunk_YCoCg_to_rgb,
+        chunk_volumetrics_taa_reproject,
+        chunk_volumetric_history_bounding_box,
+        chunk_volumetrics_taa_resolve,
+    ]
+);
+
+export const shader_volumetrics_taa = ComputeShader.from({
+    label: "Volumetric TAA",
+    resources,
+    body
 });

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

@@ -1 +1 @@
-{"version":3,"file":"WGSLJavaScriptCompiler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js"],"names":[],"mappings":"AA8bA;IAEI;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,oBAFa,MAAM,CAMlB;CACJ;;UAtda,WAAW,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS;WAClG,MAAM;WACN,MAAM;WACN,MAAM;WACN,MAAM;aACN,MAAM;cACN,QAAQ;YACR,MAAM"}
+{"version":3,"file":"WGSLJavaScriptCompiler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js"],"names":[],"mappings":"AA+bA;IAEI;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,oBAFa,MAAM,CAMlB;CACJ;;UAvda,WAAW,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS;WAClG,MAAM;WACN,MAAM;WACN,MAAM;WACN,MAAM;aACN,MAAM;cACN,QAAQ;YACR,MAAM"}

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

@@ -18,6 +18,7 @@ import LineBuilder from "../../../core/codegen/LineBuilder.js";
  */
 
 const T_UNKNOWN = Object.freeze({ kind: 'unknown' });
+const T_I32 = Object.freeze({ kind: 'primitive', name: 'i32' });
 
 const VECTOR_ALIASES = {
     vec2i: { size: 2, scalar: 'i32' },
@@ -1098,9 +1099,10 @@ function emitVariableOrValueStatement(c, node) {
 
     if (expr_node !== null) {
         const expr = compileExpression(c, expr_node);
-        // Infer the type from the RHS when no explicit annotation is present.
+        // Infer the type from the RHS when no explicit annotation is present. A bare integer
+        // literal concretises to i32 here, as WGSL does for `let x = 3;`.
         if (type === T_UNKNOWN || type.kind === 'unknown') {
-            type = expr.type;
+            type = expr.abstract_int === true ? T_I32 : expr.type;
         }
         c.scope.declare(name, type);
         c.out.add(`${kind} ${name} = ${expr.code};`);
@@ -1296,9 +1298,14 @@ function emitForInitInline(c, node) {
         const ident = namedChildByType(opt_ident, 'ident');
         const type_spec = namedChildByType(opt_ident, 'type_specifier');
         const name = ident.text;
-        const type = type_spec !== null ? parseTypeSpecifier(type_spec) : T_UNKNOWN;
+        const init = expr_node !== null ? compileExpression(c, expr_node) : null;
+        let type = type_spec !== null ? parseTypeSpecifier(type_spec) : T_UNKNOWN;
+        if (type.kind === 'unknown' && init !== null) {
+            // `for (var i = 0; ...)`: a bare integer literal concretises to i32, as in a `let`
+            type = init.abstract_int === true ? T_I32 : init.type;
+        }
         c.scope.declare(name, type);
-        const value = expr_node !== null ? compileExpression(c, expr_node).code : defaultValueForType(type);
+        const value = init !== null ? init.code : defaultValueForType(type);
         // `var i = …` (mutable, common in `for (var i = 0; ...; i = i + 1)`) → JS `let`.
         // `let i = …` / `const i = …` (immutable) → JS `const`.
         const kind = var_decl !== null ? 'let' : 'const';
@@ -1560,12 +1567,15 @@ function compileExpression(c, node) {
 
     // Primary subkinds
     if (u.type === 'literal' || u.type === 'int_literal' || u.type === 'float_literal' || u.type === 'bool_literal') {
-        return { code: literalToJs(u.text), type: literalType(u.text) };
+        // A bare integer literal is WGSL's AbstractInt. Its concrete type comes from context this
+        // compiler does not track, so the type stays unknown, but operator selection still needs
+        // to know it is an integer: see integerDivision().
+        return { code: literalToJs(u.text), type: literalType(u.text), abstract_int: isBareIntLiteral(u.text) };
     }
     if (u.type === 'paren_expression') {
         const inner = namedChildByType(u, 'expression');
         const e = compileExpression(c, inner);
-        return { code: `(${e.code})`, type: e.type };
+        return { code: `(${e.code})`, type: e.type, abstract_int: e.abstract_int };
     }
     if (u.type === 'call_expression') {
         const call_phrase = namedChildByType(u, 'call_phrase');
@@ -1631,16 +1641,18 @@ function compileBinaryExpression(c, node, op_type, mode) {
                 const dispatched = dispatchMatrixMul(left, right);
                 if (dispatched !== null) return dispatched;
             }
-            // WGSL `/` on integer types is truncated integer division. Detect when both
-            // operands' tracked types are integer (i32 / u32 scalars or matching int vecs)
-            // and route through the integer-truncating helper; otherwise use float div.
+            // WGSL `/` on integer types is truncated integer division. Route through the
+            // integer-truncating helper when WGSL would type the division as integer;
+            // otherwise use float div.
             let actual_helper = helper;
-            if (op_text === '/' && bothOperandsInteger(left.type, right.type)) {
+            if (op_text === '/' && integerDivision(left, right)) {
                 actual_helper = 'idiv';
             }
             return {
                 code: `wgsl.${actual_helper}(${left.code}, ${right.code})`,
                 type: inferBinaryArithResultType(left.type, right.type),
+                // arithmetic on two AbstractInts is still AbstractInt: `(1 + 2) / 2` is 1
+                abstract_int: left.abstract_int === true && right.abstract_int === true,
             };
         }
     }
@@ -1710,15 +1722,29 @@ function isScalarUnsigned(t) {
     return t && t.kind === 'primitive' && t.name === 'u32';
 }
 
-/** True if both operands are integer-typed (scalar or vec of i32/u32). */
-function bothOperandsInteger(a, b) {
-    const isInt = (t) => {
-        if (!t) return false;
-        if (t.kind === 'primitive') return t.name === 'i32' || t.name === 'u32';
-        if (t.kind === 'vec' || t.kind === 'mat') return t.scalar === 'i32' || t.scalar === 'u32';
-        return false;
-    };
-    return isInt(a) && isInt(b);
+/** True if `t` is an integer type (scalar or vec/mat of i32/u32). */
+function isIntegerType(t) {
+    if (!t) return false;
+    if (t.kind === 'primitive') return t.name === 'i32' || t.name === 'u32';
+    if (t.kind === 'vec' || t.kind === 'mat') return t.scalar === 'i32' || t.scalar === 'u32';
+    return false;
+}
+
+/** True if the literal's spelling is a bare integer: no suffix, no fraction, no exponent. */
+function isBareIntLiteral(text) {
+    return /^(0[xX][0-9a-fA-F]+|[0-9]+)$/.test(text.trim());
+}
+
+/**
+ * True if WGSL evaluates `left / right` as integer division. Both operands integer-typed is the
+ * obvious case. A bare literal is AbstractInt and takes the other operand's integer type, so
+ * `index / 3` truncates; two bare literals divide as AbstractInt, so `7 / 2` is 3 even where an
+ * f32 is expected. Negation and parentheses keep a literal abstract: `index / -3` and
+ * `index / (3)` truncate too.
+ */
+function integerDivision(left, right) {
+    const isInt = (operand) => isIntegerType(operand.type) || operand.abstract_int === true;
+    return isInt(left) && isInt(right);
 }
 
 /**
@@ -1827,7 +1853,7 @@ function compileUnaryExpression(c, node) {
 
     const operand = compileExpression(c, named[named.length - 1]);
 
-    if (prefix === '-') return { code: `wgsl.neg(${operand.code})`, type: operand.type };
+    if (prefix === '-') return { code: `wgsl.neg(${operand.code})`, type: operand.type, abstract_int: operand.abstract_int };
     if (prefix === '!') return { code: `!${operand.code}`, type: operand.type };
     if (prefix === '~') return { code: `wgsl.not(${operand.code})`, type: operand.type };
     if (prefix === '*' || prefix === '&') return { code: operand.code, type: operand.type };
@@ -1853,7 +1879,9 @@ function compileSingularExpression(c, node) {
         type = next.type;
     }
 
-    return { code, type };
+    // a bare literal reached through a singular expression is still AbstractInt; anything with an
+    // access specifier on it is not a literal
+    return { code, type, abstract_int: named.length === 1 ? head_result.abstract_int : undefined };
 }
 
 /**