From a9fa61ce77933895f7b178f959cc6ae27a785a2b Mon Sep 17 00:00:00 2001 From: austin62jake Date: Mon, 2 Nov 2026 13:46:45 +0000 Subject: [PATCH] Viewport: the shader compiles in browsers again, so the web app's 3D view isn't black (#11080) (#11107) * claim: #11080 Co-Authored-By: Claude Opus 5.5 * Viewport: the shader compiles in browsers again (#11080) The ambient occlusion turn added in #9335 mixed `<<` and `|` without parentheses. naga accepts that, so the desktop app ran, but browsers' WGSL compiler refuses it: the sc_viewport module was invalid, every pipeline built from it failed, and the web app drew nothing once a design was open. The line gets its parentheses, and a test checks every shader in the repository for the rule. Co-Authored-By: Claude Opus 5.5 --------- Co-authored-by: Claude --- assets/shaders/viewport.wgsl | 3 +- crates/gpu/src/tests.rs | 92 ++++++++++++++++++++++++++++++++++++ 2 files changed, 94 insertions(+), 1 deletion(-) diff --git a/assets/shaders/viewport.wgsl b/assets/shaders/viewport.wgsl index fd042eda5..44477ff5a 100644 --- a/assets/shaders/viewport.wgsl +++ b/assets/shaders/viewport.wgsl @@ -413,7 +413,8 @@ fn fs_ao_blur(@builtin(position) pos: vec4) -> @location(0) vec4 { fn ao_turn(pos: vec2) -> f32 { let x = u32(pos.x) & 3u; let y = u32(pos.y) & 3u; - let v = ((x ^ y) & 1u) << 3u | (y & 1u) << 2u | ((x ^ y) >> 1u) << 1u | (y >> 1u); + // WGSL won't mix shifts and `|` without parentheses; naga takes it, browsers refuse it (#11080). + let v = (((x ^ y) & 1u) << 3u) | ((y & 1u) << 2u) | (((x ^ y) >> 1u) << 1u) | (y >> 1u); return (f32(v) + 0.5) / 16.0; } diff --git a/crates/gpu/src/tests.rs b/crates/gpu/src/tests.rs index 9492fe908..b9020e24a 100644 --- a/crates/gpu/src/tests.rs +++ b/crates/gpu/src/tests.rs @@ -96,6 +96,98 @@ fn the_hlsl_for_fxc_has_no_arrays_fxc_must_unroll_loops_for() { } } +/// Browsers compile WGSL with Tint, which keeps a rule of the WGSL grammar that naga doesn't: a +/// shift, `&`, `|` and `^` don't mix in one expression without parentheses (`a << 3u | b` is +/// refused, `(a << 3u) | b` isn't). A shader that breaks it runs on the desktop and leaves the +/// web app's 3D view black (#11080). Every shader in the repository keeps to it. +#[test] +fn no_shader_mixes_shifts_and_bitwise_operators_without_parentheses() { + let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../.."); + let mut shaders = Vec::new(); + let mut dirs = vec![root.join("assets"), root.join("crates"), root.join("vendor")]; + while let Some(dir) = dirs.pop() { + for entry in ok(std::fs::read_dir(&dir)) { + let path = ok(entry).path(); + if path.is_dir() { + if !path.ends_with("target") { + dirs.push(path); + } + } else if path.extension().is_some_and(|e| e == "wgsl") { + shaders.push(path); + } + } + } + assert!(shaders.iter().any(|p| p.ends_with("assets/shaders/viewport.wgsl")), "{shaders:?}"); + let mut found = Vec::new(); + for path in &shaders { + for (n, line) in ok(std::fs::read_to_string(path)).lines().enumerate() { + if let Some(ops) = mixed_bitwise(line) { + found.push(format!("{}:{}: {ops}: {}", path.display(), n + 1, line.trim())); + } + } + } + assert!(found.is_empty(), "{}", found.join("\n")); + // The check finds the line #11080 reported, and takes it parenthesized. + assert_eq!(mixed_bitwise("let v = ((x ^ y) & 1u) << 3u | (y & 1u) << 2u;").as_deref(), Some("shift and |")); + assert_eq!(mixed_bitwise("let v = (((x ^ y) & 1u) << 3u) | ((y & 1u) << 2u);"), None); + assert_eq!(mixed_bitwise("let a = f(&p, x & 1u, y | 2u) && b || c; // x << 1u | y"), None); + assert_eq!(mixed_bitwise("var m: array>; let b = a & 1u ^ c;").as_deref(), Some("& and ^")); +} + +/// The bitwise operators (a shift, `&`, `|`, `^`) that one parenthesized group of a WGSL line +/// mixes, when it mixes more than one: what WGSL needs parentheses for. `&&`, `||`, an +/// address-of `&` and a `>>` closing two generic brackets (`vec2>`) aren't counted. +fn mixed_bitwise(line: &str) -> Option { + let chars: Vec = line.split("//").next().unwrap_or("").chars().collect(); + let at = |i: usize| chars.get(i).copied().unwrap_or(' '); + let mixed = |g: &Vec<&str>| (g.len() > 1).then(|| g.join(" and ")); + let mut groups: Vec> = vec![Vec::new()]; + let (mut i, mut prev) = (0, ' '); + while i < chars.len() { + let (c, next) = (at(i), at(i + 1)); + let mut op = None; + match c { + '(' | '[' => groups.push(Vec::new()), + ')' | ']' | ',' | ';' | '{' | '}' => { + if let Some(m) = groups.last().and_then(mixed) { + return Some(m); + } + if matches!(c, ')' | ']') && groups.len() > 1 { + groups.pop(); + } else if let Some(g) = groups.last_mut() { + g.clear(); + } + } + '<' if next == '<' => { + op = Some("shift"); + i += 1; + } + '>' if next == '>' => { + let after = at(i + 2); + if after == ' ' || after == '_' || after.is_alphanumeric() { + op = Some("shift"); + } + i += 1; + } + '&' | '|' if next == c => i += 1, + '&' if prev == '_' || prev == ')' || prev == ']' || prev.is_alphanumeric() => op = Some("&"), + '|' => op = Some("|"), + '^' => op = Some("^"), + _ => {} + } + if let (Some(op), Some(g)) = (op, groups.last_mut()) + && !g.contains(&op) + { + g.push(op); + } + if !at(i).is_whitespace() { + prev = at(i); + } + i += 1; + } + groups.iter().find_map(mixed) +} + fn ok(r: std::result::Result) -> T { match r { Ok(v) => v,