2c424c4 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

2c424c4 — Peter John 2026-11-02T17:25:03+05:30

plum_bridge: HiDPI backing store and GPU device-loss recovery; web-test --dpr and --lose-device

Files changed (3) hide show

plum-game/web-test/src/lib.rs +59 -2
plum-game/web-test/src/main.rs +4 -1
plum-game/web/plum_bridge.js +148 -67

plum-game/web-test/src/lib.rs CHANGED Viewed

@@ -22,6 +22,10 @@ pub struct Options {
     pub json: bool,
     /// Lift Chromium's vsync / frame-rate cap so frame times show the work per frame.
     pub uncapped: bool,
+    /// Browser `devicePixelRatio` (Playwright `deviceScaleFactor`); the page default when None.
+    pub dpr: Option<f64>,
+    /// Destroy the GPU device from the page after a few frames and require rendering to resume.
+    pub lose_device: bool,
 }
 impl Default for Options {
@@ -35,6 +39,8 @@ impl Default for Options {
             measure: None,
             json: false,
             uncapped: false,
+            dpr: None,
+            lose_device: false,
         }
     }
 }
@@ -319,7 +325,14 @@ async fn check(port: u16, opts: &Options) -> Result<String, String> {
 }
 async fn check_page(browser: &playwright_rs::protocol::Browser, port: u16, opts: &Options) -> Result<String, String> {
+    let page = match opts.dpr {
+        Some(d) => {
+            let ctx_opts = playwright_rs::protocol::BrowserContextOptions::builder().device_scale_factor(d).build();
+            let ctx = browser.new_context_with_options(ctx_opts).await.map_err(pe("new context"))?;
+            ctx.new_page().await.map_err(pe("new page"))?
+        }
-    let page = browser.new_page().await.map_err(pe("new page"))?;
+        None => browser.new_page().await.map_err(pe("new page"))?,
+    };
     let errors: Arc<Mutex<Vec<String>>> = Arc::default();
     let logs: Arc<Mutex<Vec<String>>> = Arc::default();
     {
@@ -351,6 +364,9 @@ async fn check_page(browser: &playwright_rs::protocol::Browser, port: u16, opts:
         .map_err(pe("on_pageerror"))?;
     }
     page.add_init_script(AUDIO_HOOK).await.map_err(pe("init script"))?;
+    if opts.lose_device {
+        page.add_init_script("window.__plumExposeDevice = true;").await.map_err(pe("init script"))?;
+    }
     page.add_init_script(RAF_PROBE).await.map_err(pe("init script"))?;
     page.goto(&format!("http://127.0.0.1:{port}/"), None).await.map_err(pe("goto"))?;
@@ -363,6 +379,31 @@ async fn check_page(browser: &playwright_rs::protocol::Browser, port: u16, opts:
     page.mouse().click(size[0] / 2.0, size[1] / 2.0, None).await.map_err(pe("click"))?;
     tokio::time::sleep(Duration::from_secs_f64((opts.frames_wait - (opts.frames_wait / 2.0).min(3.0)).max(0.0))).await;
+    let mut loss_failure = None;
+    if opts.lose_device {
+        let before: f64 = page.evaluate("() => window.plumFrames || 0", None::<&()>).await.unwrap_or(0.0);
+        let destroyed: bool = page
+            .evaluate("() => { if (!window.__plumDevice) return false; window.__plumDevice.destroy(); return true; }", None::<&()>)
+            .await
+            .unwrap_or(false);
+        tokio::time::sleep(Duration::from_secs(3)).await;
+        let after: f64 = page.evaluate("() => window.plumFrames || 0", None::<&()>).await.unwrap_or(0.0);
+        let restored = logs.lock().unwrap().iter().any(|l| l.contains("GPU device lost (") && l.ends_with("; restored"));
+        loss_failure = if !destroyed {
+            Some("--lose-device: the page exposed no GPU device".to_string())
+        } else if !restored {
+            Some("--lose-device: no 'GPU device lost (...); restored' log after device.destroy()".to_string())
+        } else if after < before + 10.0 {
+            Some(format!("--lose-device: rendering did not resume (frames drawn {before} -> {after})"))
+        } else {
+            None
+        };
+    }
+    let backing: Vec<f64> = page
+        .evaluate("() => { const c = document.getElementById('glcanvas'); return [c.width, c.height, window.devicePixelRatio, c.clientWidth, c.clientHeight]; }", None::<&()>)
+        .await
+        .unwrap_or_default();
     let renderer: Option<String> = page.evaluate("() => window.plumRenderer || null", None::<&()>).await.unwrap_or(None);
     let mut measured = None;
     let mut phases = None;
@@ -396,6 +437,7 @@ async fn check_page(browser: &playwright_rs::protocol::Browser, port: u16, opts:
     let colours = distinct_colours(&b, 1000);
     let diff = differing_pixels(&a, &b);
     let errs = errors.lock().unwrap().clone();
+    let mut failures_pre: Vec<String> = vec![];
     let mut report = format!(
         "canvas {}x{}, distinct colours: {colours}{}, pixels changed over 1s: {}\naudio: {}",
@@ -433,7 +475,22 @@ async fn check_page(browser: &playwright_rs::protocol::Browser, port: u16, opts:
     if opts.json {
         report.push_str(&format!("\n{}", stats_json(opts, renderer.as_deref(), measured.as_ref(), phases.as_ref())));
     }
+    if let [bw, bh, ratio, cw, ch] = backing[..] {
+        report.push_str(&format!("\nbacking store {bw}x{bh} for CSS {cw}x{ch} at devicePixelRatio {ratio}"));
+        if (bw - (cw * ratio).round()).abs() > 1.0 || (bh - (ch * ratio).round()).abs() > 1.0 {
+            failures_pre.push(format!("backing store {bw}x{bh} is not CSS {cw}x{ch} x devicePixelRatio {ratio}"));
+        }
+        if let Some(d) = opts.dpr {
+            if (ratio - d).abs() > 1e-6 {
+                failures_pre.push(format!("--dpr {d}: the page reports devicePixelRatio {ratio}"));
+            }
+        }
+    }
+    if opts.lose_device {
+        report.push_str(if loss_failure.is_none() { "\ndevice loss: destroyed, restored, rendering resumed" } else { "\ndevice loss: FAILED" });
+    }
-    let mut failures = vec![];
+    let mut failures = failures_pre;
+    failures.extend(loss_failure);
     if renderer.is_none() {
         failures.push("the page did not set globalThis.plumRenderer (WebGPU failed to start?)".to_string());
     }

plum-game/web-test/src/main.rs CHANGED Viewed

@@ -1,7 +1,8 @@
 use plum_web_test::{chromium_installed, run, Options};
 use std::path::PathBuf;
-const USAGE: &str = "usage: plum-web-test <file.plum> [--frames-wait SECS] [--screenshot OUT.png] [--require-audio]\n  [--assets DIR] [--headed] [--measure SECS] [--uncapped] [--json]";
+const USAGE: &str = "usage: plum-web-test <file.plum> [--frames-wait SECS] [--screenshot OUT.png] [--require-audio]\n  [--assets DIR] [--headed] [--measure SECS] [--uncapped] [--json]
+  [--dpr N] [--lose-device]";
 #[tokio::main]
 async fn main() {
@@ -18,6 +19,8 @@ async fn main() {
             "--headed" => opts.headed = true,
             "--uncapped" => opts.uncapped = true,
             "--json" => opts.json = true,
+            "--lose-device" => opts.lose_device = true,
+            "--dpr" => opts.dpr = Some(args.next().and_then(|v| v.parse().ok()).unwrap_or_else(|| fail("--dpr needs a number"))),
             "--measure" => opts.measure = Some(args.next().and_then(|v| v.parse().ok()).unwrap_or_else(|| fail("--measure needs a number of seconds"))),
             "--assets" => opts.assets = Some(args.next().map(PathBuf::from).unwrap_or_else(|| fail("--assets needs a directory"))),
             "-h" | "--help" => {

plum-game/web/plum_bridge.js CHANGED Viewed

@@ -280,8 +280,9 @@
     let texSeq = 0;
     const white = { w: 1, h: 1, white: true, uid: texSeq++ };
     const textures = []; // handle -> texture object { w, h, uid, smooth, ... }
-    let sw = 1;
+    let sw = 1; // screen size in CSS pixels (the unit of game coordinates)
     let sh = 1;
+    let dpr = 1; // device pixels per CSS pixel
     const cam = { x: 0, y: 0, s: 1 };
     // world -> clip: X = x * mx + bx, Y = y * my + by
     let mx = 2;
@@ -373,10 +374,11 @@
       white,
       cam,
       clearColor,
-      // Per-frame state; (w, h) is the screen size in pixels.
+      // Per-frame state; (w, h) is the screen size in CSS pixels.
-      beginFrame(w, h) {
+      beginFrame(w, h, ratio) {
         sw = w;
         sh = h;
+        dpr = ratio;
         vn = 0;
         inn = 0;
         nb = 0;
@@ -416,7 +418,7 @@
       },
       drawCircle(x, y, rad, r, g, b, a) {
         if (!(rad > 0)) return;
-        const n = Math.min(MAX_SEGMENTS, Math.max(24, Math.ceil(rad * cam.s * 0.6)));
+        const n = Math.min(MAX_SEGMENTS, Math.max(24, Math.ceil(rad * cam.s * dpr * 0.6)));
         reserve(n + 1, n * 3);
         useTex(white);
         const c = packColor(r, g, b, a);
@@ -433,13 +435,13 @@
         cur.count += n * 3;
       },
       // `x, y` is the text's top-left. The run is rasterised at its on-screen
-      // size (size * camera scale), so it is drawn 1:1 in screen pixels.
+      // size in device pixels (size * camera scale * dpr), so it is drawn 1:1.
       drawText(str, x, y, size, r, g, b, a) {
         if (!str) return;
-        const px = Math.max(1, Math.round(size * cam.s));
+        const px = Math.max(1, Math.round(size * cam.s * dpr));
         const t = env.textTexture(str, px);
         if (!t) return;
-        const s = cam.s;
+        const s = cam.s * dpr;
         const x0 = x - t.pad / s;
         const y0 = y - t.pad / s;
         const x1 = x0 + t.w / s;
@@ -538,56 +540,119 @@ ${cases}    default: { return vec4f(1.0); }
   }
   const WGSL = makeWGSL();
+  // The WebGPU backend. Everything that belongs to the device lives in `setup`, so a
+  // lost device is replaced by requesting a new one, building that state again and
+  // re-uploading every live texture from its kept source (an ImageBitmap or pixel
+  // data; render-target contents are lost and start transparent).
+  // `onLost(reason, restored)` reports a loss and whether a new device was obtained.
-  async function makeWebGPU(canvas, b) {
+  async function makeWebGPU(canvas, b, onLost) {
     const white = b.white;
     if (!navigator.gpu) return null;
-    const adapter = await navigator.gpu.requestAdapter();
-    if (!adapter) return null;
-    const device = await adapter.requestDevice();
     const ctx = canvas.getContext("webgpu");
     if (!ctx) return null;
     const format = navigator.gpu.getPreferredCanvasFormat();
-    ctx.configure({ device, format, alphaMode: "opaque" });
-    const module = device.createShaderModule({ code: WGSL });
+    let device = null;
-    const pipeline = device.createRenderPipeline({
+    let pipeline = null;
-      layout: "auto",
+    let layout = null;
-      vertex: {
-        module,
-        entryPoint: "vs",
-        buffers: [{
-          arrayStride: VERT_BYTES,
-          attributes: [
-            { shaderLocation: 0, format: "float32x2", offset: 0 },
-            { shaderLocation: 1, format: "float32x2", offset: 8 },
-            { shaderLocation: 2, format: "unorm8x4", offset: 16 },
-            { shaderLocation: 3, format: "uint32", offset: 20 },
-          ],
-        }],
-      },
-      fragment: {
-        module,
-        entryPoint: "fs",
-        targets: [{
+    let nearest = null;
-          format,
-          blend: {
-            color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" },
-            alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
-          },
-        }],
-      },
-      primitive: { topology: "triangle-list" },
-    });
-    const layout = pipeline.getBindGroupLayout(0);
+    let linear = null;
-    const nearest = device.createSampler({ magFilter: "nearest", minFilter: "nearest" });
-    const linear = device.createSampler({ magFilter: "linear", minFilter: "linear" });
     let vbuf = null;
     let vsize = 0;
     let ibuf = null;
     let isize = 0;
+    const groups = new Map(); // bind groups by the textures of a draw's slots
+    const live = new Set(); // every texture that has GPU memory
+    async function acquire() {
+      const adapter = await navigator.gpu.requestAdapter();
+      return adapter ? adapter.requestDevice() : null;
+    }
+    function setup(dev) {
+      device = dev;
+      if (globalThis.__plumExposeDevice) globalThis.__plumDevice = dev; // set by plum-web-test --lose-device
+      ctx.configure({ device, format, alphaMode: "opaque" });
+      const module = device.createShaderModule({ code: WGSL });
+      pipeline = device.createRenderPipeline({
+        layout: "auto",
+        vertex: {
+          module,
+          entryPoint: "vs",
+          buffers: [{
+            arrayStride: VERT_BYTES,
+            attributes: [
+              { shaderLocation: 0, format: "float32x2", offset: 0 },
+              { shaderLocation: 1, format: "float32x2", offset: 8 },
+              { shaderLocation: 2, format: "unorm8x4", offset: 16 },
+              { shaderLocation: 3, format: "uint32", offset: 20 },
+            ],
+          }],
+        },
+        fragment: {
+          module,
+          entryPoint: "fs",
+          targets: [{
+            format,
+            blend: {
+              color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" },
+              alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
+            },
+          }],
+        },
+        primitive: { topology: "triangle-list" },
+      });
+      layout = pipeline.getBindGroupLayout(0);
+      nearest = device.createSampler({ magFilter: "nearest", minFilter: "nearest" });
+      linear = device.createSampler({ magFilter: "linear", minFilter: "linear" });
+      vbuf = ibuf = null;
+      vsize = isize = 0;
+      groups.clear();
+      for (const t of live) allocate(t);
+      device.lost.then((info) => recover(info.reason || "unknown"));
+    }
+    // Gives `t` GPU memory on the current device and uploads its source.
+    function allocate(t) {
+      const gpu = device.createTexture({
+        size: [t.w, t.h],
+        format: "rgba8unorm",
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
+      });
+      const src = t.source;
+      if (t.white) device.queue.writeTexture({ texture: gpu }, new Uint8Array([255, 255, 255, 255]), { bytesPerRow: 4 }, [1, 1]);
+      else if (src && src.data) device.queue.writeTexture({ texture: gpu }, src.data, { bytesPerRow: t.w * 4 }, [t.w, t.h]);
+      else if (src) device.queue.copyExternalImageToTexture({ source: src }, { texture: gpu }, [t.w, t.h]);
+      t.gpu = gpu;
+      t.view = gpu.createView();
+    }
+    let recovering = false;
+    async function recover(reason) {
+      recovering = true;
+      let dev = null;
+      try {
+        dev = await acquire();
+      } catch (e) {
+        console.error("GPU device request failed:", e);
+      }
+      if (!dev) {
+        onLost(reason, false);
+        return; // stays lost: submit draws nothing
+      }
+      setup(dev);
+      recovering = false;
+      onLost(reason, true);
+    }
+    function createTexture(source, w, h, smooth, uid) {
+      const t = { w, h, uid, source, smooth: !!smooth, bid: 0, slot: 0 };
+      live.add(t);
+      if (!recovering) allocate(t);
+      return t;
+    }
     // Bind groups by the textures of a draw's slots (unused slots hold the white texture).
-    const groups = new Map();
-    function bindGroup(batch, white) {
+    function bindGroup(batch) {
       let key = "";
       for (let i = 0; i < SLOTS; i++) key += (i < batch.n ? batch.slots[i].uid : white.uid) + ",";
       let bg = groups.get(key);
@@ -600,18 +665,16 @@ ${cases}    default: { return vec4f(1.0); }
       }
       return bg;
     }
-    function createTexture(source, w, h, smooth, uid) {
-      const gpu = device.createTexture({
+    const first = await acquire();
+    if (!first) return null;
+    white.white = true;
-        size: [w, h],
+    white.w = 1;
+    white.h = 1;
-        format: "rgba8unorm",
+    white.source = null;
-        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-      });
-      if (source && source.data) device.queue.writeTexture({ texture: gpu }, source.data, { bytesPerRow: w * 4 }, [w, h]);
-      else if (source) device.queue.copyExternalImageToTexture({ source }, { texture: gpu }, [w, h]);
-      else device.queue.writeTexture({ texture: gpu }, new Uint8Array([255, 255, 255, 255]), { bytesPerRow: 4 }, [1, 1]);
-      return { w, h, uid, gpu, view: gpu.createView(), smooth: !!smooth, bid: 0, slot: 0 };
-    }
-    Object.assign(white, createTexture(null, 1, 1, false, white.uid));
+    white.smooth = false;
+    live.add(white);
+    setup(first);
     return {
       name: "gpu-webgpu",
@@ -620,10 +683,13 @@ ${cases}    default: { return vec4f(1.0); }
         t.smooth = !!smooth;
       },
       destroyTexture(t) {
+        live.delete(t);
         groups.clear();
         t.gpu.destroy();
       },
+      // Draws the batcher's frame; returns the number of draw calls issued.
       submit(b) {
+        if (recovering || !device) return 0;
         const vbytes = b.vertexCount * VERT_BYTES;
         const ibytes = b.indexCount * 4;
         if (vbytes > vsize) {
@@ -656,12 +722,13 @@ ${cases}    default: { return vec4f(1.0); }
           pass.setIndexBuffer(ibuf, "uint32");
           for (let i = 0; i < b.batchCount; i++) {
             const bt = b.batches[i];
-            pass.setBindGroup(0, bindGroup(bt, white));
+            pass.setBindGroup(0, bindGroup(bt));
             pass.drawIndexed(bt.count, 1, bt.start);
           }
         }
         pass.end();
         device.queue.submit([enc.finish()]);
+        globalThis.plumFrames = (globalThis.plumFrames || 0) + 1;
         return vbytes ? b.batchCount : 0;
       },
     };
@@ -723,26 +790,40 @@ ${cases}    default: { return vec4f(1.0); }
   async function main() {
     const canvas = document.getElementById("glcanvas");
+    // Game coordinates are CSS pixels; the backing store is CSS size x devicePixelRatio.
+    const view = { w: 1, h: 1, dpr: 1 };
     const size = () => {
+      view.dpr = window.devicePixelRatio || 1;
-      const w = Math.max(1, window.innerWidth | 0);
+      view.w = Math.max(1, canvas.clientWidth || window.innerWidth | 0);
+      view.h = Math.max(1, canvas.clientHeight || window.innerHeight | 0);
+      const w = Math.max(1, Math.round(view.w * view.dpr));
-      const h = Math.max(1, window.innerHeight | 0);
+      const h = Math.max(1, Math.round(view.h * view.dpr));
       if (canvas.width !== w) canvas.width = w;
       if (canvas.height !== h) canvas.height = h;
     };
     size();
+    const message = (text, color) =>
+      document.body.append(Object.assign(document.createElement("pre"), { textContent: text, style: "position:fixed;top:0;left:0;color:" + color + ";margin:8px;font-size:18px" }));
     let backend = null;
     const text = makeTextCache(() => backend);
     const b = makeBatcher({ textTexture: text.textTexture });
     try {
-      backend = await makeWebGPU(canvas, b);
+      backend = await makeWebGPU(canvas, b, (reason, restored) => {
+        if (restored) {
+          console.log("GPU device lost (" + reason + "); restored");
+        } else {
+          console.error("GPU device lost (" + reason + "); no new device");
+          message("The GPU device was lost (" + reason + ") and could not be restored. Reload the page.", "#f55");
+        }
+      });
     } catch (e) {
       console.error("WebGPU failed to start:", e);
     }
     if (!backend) {
       const msg = "WebGPU is not supported in this browser";
       console.error(msg);
-      document.body.append(Object.assign(document.createElement("pre"), { textContent: msg, style: "position:fixed;top:0;left:0;color:#f55;margin:8px;font-size:18px" }));
+      message(msg, "#f55");
       return;
     }
     globalThis.plumRenderer = backend.name;
@@ -772,8 +853,8 @@ ${cases}    default: { return vec4f(1.0); }
     let dt = 1 / 60;
     const host = {
-      screenWidth: () => canvas.width,
+      screenWidth: () => view.w,
-      screenHeight: () => canvas.height,
+      screenHeight: () => view.h,
       frameTime: () => dt,
       clear: b.clear,
       drawRect: b.drawRect,
@@ -851,14 +932,14 @@ ${cases}    default: { return vec4f(1.0); }
         last = now;
         size();
         input.beginFrame();
-        b.beginFrame(canvas.width, canvas.height);
+        b.beginFrame(view.w, view.h, view.dpr);
         const m = globalThis.__plumMeasure; // set by plum-web-test --measure; null otherwise
         const t0 = m ? performance.now() : 0;
         ex.update(state, dt);
         const t1 = m ? performance.now() : 0;
         ex.draw(state);
         const t2 = m ? performance.now() : 0;
-        const draws = backend.submit(b, canvas.width, canvas.height);
+        const draws = backend.submit(b);
         if (m) { m.n++; m.u += t1 - t0; m.d += t2 - t1; m.r += performance.now() - t2; m.dr += draws; }
         text.endFrame();
       } catch (e) {