struct Uniforms {
     mvp: mat4x4<f32>,
     window_size: vec2<f32>,
     window_radius: f32,
     // Corner-shape exponent shared with shader2d: circular arc at 2,
     // superellipse squircle above.
     corner_shape: f32,
     // rgb + mix: fragment color mixed toward .rgb by .a. Zero = vertex
     // colors untouched; a wireframe pass overlaid on its own filled mesh
     // sets it so the lines separate from the identical fill beneath.
     wire_tint: vec4<f32>,
     // Whole-draw alpha multiplier (straight-alpha blend): 1 = opaque.
     opacity: f32,
     // 1 on wireframe draws: skip the derivative-normal shading — the
     // screen-space derivatives of a line fragment are along-axis only, so
     // the "normal" is noise and speckles the wires.
     is_wire: f32,
     // 1 on a draw whose vertex colours are already lit (the host baked
     // smooth shading from vertex normals against the same world light):
     // skip the flat shading below so it is not applied twice.
     prelit: f32,
     // 1 on a `SceneDraw::screen_space` draw (a pane's background quad): the
     // vertex's xy are already NDC, so it skips the mvp and sits at the far
     // plane, unlit. A per-draw flag, never read off the vertex data: the
     // z = 9.99 sentinel it replaced caught real geometry on that plane.
     screen_space: f32,
     // xyz: the direction TOWARD the light, in world space
     // (`VkRenderer::set_scene_light`). Unit length.
     light: vec4<f32>,
 }
 
 @group(0) @binding(0) var<uniform> uniforms: Uniforms;
 
 // Signed distance to the window's rounded silhouette — shader2d's
 // window_corner_distance, kept in lockstep so the 3D scene fill cuts along the
 // exact curve the 2D pass (and the plates' tessellated corners) use: positive
 // outside the corner arcs and past the window bounds, large-negative on the
 // straight edges (those keep their hard cut).
 fn window_corner_distance(pos: vec2<f32>) -> f32 {
     let w = uniforms.window_size.x;
     let h = uniforms.window_size.y;
     let r = uniforms.window_radius;
 
     if (pos.x < 0.0 || pos.x > w || pos.y < 0.0 || pos.y > h) {
         return 1e5;
     }
     if (r <= 0.0) {
         return -1e5;
     }
     let q = abs(pos - vec2f(w * 0.5, h * 0.5)) - vec2f(w * 0.5 - r, h * 0.5 - r);
     if (q.x > 0.0 && q.y > 0.0) {
         let shape = uniforms.corner_shape;
         if (shape > 2.001) {
             let lp = max(pow(pow(q.x, shape) + pow(q.y, shape), 1.0 / shape), 1e-4);
             let g = vec2f(pow(q.x / lp, shape - 1.0), pow(q.y / lp, shape - 1.0));
             return (lp - r) / max(length(g), 1e-4);
         }
         return length(q) - r;
     }
     return -1e5;
 }
 
 struct VertexOutput {
     @builtin(position) position: vec4f,
     @location(0) color: vec3f,
     // World-space position, for the flat-shading normal; `lit` is 0 on a
     // screen-space draw (the background quad), 1 on scene geometry.
     @location(1) world: vec3f,
     @location(2) lit: f32,
 };
 
 // The vertex, and the instance it is drawn for (`SceneDraw::instances`):
 // the instance's offset is added to the vertex and its colour multiplies the
 // vertex's. A draw without instances is drawn for one at the origin in white,
 // which changes nothing.
 @vertex
 fn vs_main(
     @location(0) position: vec3f,
     @location(1) color: vec3f,
     @location(2) instance_offset: vec3f,
     @location(3) instance_color: vec3f,
 ) -> VertexOutput {
     var out: VertexOutput;
     let placed = position + instance_offset;
     if (uniforms.screen_space > 0.5) {
         out.position = vec4f(position.xy, 0.9999, 1.0);
         out.lit = 0.0;
     } else {
         out.position = uniforms.mvp * vec4f(placed, 1.0);
         out.lit = 1.0;
     }
     out.color = color * instance_color;
     out.world = placed;
     return out;
 }
 
 @fragment
 fn fs_main(in: VertexOutput) -> @location(0) vec4f {
     // The world position's screen-space derivatives, for the flat shading
     // below — taken here, in uniform control flow: WebGPU rejects a
     // derivative under a branch on a varying (`in.lit`), and the values are
     // the same wherever in the invocation they are read.
     let world_dx = dpdx(in.world);
     let world_dy = dpdy(in.world);
     // ~1px feather along the squircle window corner (the pass clears to
     // transparent and blends with straight alpha, so partial coverage fades
     // the scene out exactly at the silhouette).
     let cov = 1.0 - smoothstep(-0.5, 0.5, window_corner_distance(in.position.xy));
     if (cov <= 0.0) {
         discard;
     }
     var rgb = mix(in.color, uniforms.wire_tint.rgb, uniforms.wire_tint.a);
     // Flat shading off a fixed WORLD light: the facet normal comes from the
     // screen-space derivatives of the world position, so every facet keeps a
     // brightness pinned to its world orientation. That anchoring is what makes
     // an orbit read as the camera moving around stationary geometry — an unlit
     // scene's only cues are the vertex colors, and any rotationally
     // self-similar surface (a UV sphere's lattice, especially under a
     // wireframe overlay whose fill occludes the back wires) reads as glued to
     // the camera without it. Two-sided so unculled back faces stay sane.
     if (in.lit > 0.5 && uniforms.is_wire < 0.5 && uniforms.prelit < 0.5) {
         let n = normalize(cross(world_dx, world_dy));
         // A strongly AZIMUTHAL light, wrap-shaded. A near-vertical light (or a
         // two-sided |dot|) yields a latitude-dominated / 180-degree-symmetric
         // brightness pattern — invariant under a yaw orbit, which reads as the
         // scene turning with the camera. The horizontal component pins the lit
         // side to a world azimuth the orbit visibly sweeps across; the wrap
         // term keeps a soft floor without |dot|'s ambiguity (the fill pass
         // culls to front faces, so the derivative normal's sign is stable).
         // `n` is screen-right x framebuffer-DOWN, which for a visible
         // face points INTO the surface, so the outward normal is `-n`.
         let d = clamp(dot(-n, uniforms.light.xyz) * 0.5 + 0.5, 0.0, 1.0);
         rgb = rgb * (0.55 + 0.45 * d);
     }
     return vec4f(rgb, cov * uniforms.opacity);
 }