4f8f99a | plum | pyrossh

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

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

4f8f99a — Peter John 2026-11-02T17:00:46+05:30

web-test: always the own renderer, --assets passthrough; benchmark outcome note; regenerate docs/game.png

Files changed (6) hide show

docs/game.png +0 -0
plum-game/web-test/BENCHMARK.md +2 -0
plum-game/web-test/README.md +9 -9
plum-game/web-test/src/lib.rs +32 -62
plum-game/web-test/src/main.rs +3 -10
plum-game/web-test/tests/web_check.rs +13 -20

docs/game.png CHANGED Viewed

Binary file

plum-game/web-test/BENCHMARK.md CHANGED Viewed

@@ -1,5 +1,7 @@
 # Web renderer benchmark: macroquad vs PixiJS vs our gpu renderer
+**Outcome:** browser-only engine on the gpu renderer (per-call); macroquad, Pixi and the command buffer were removed after this benchmark (see git history).
 Browser renderers for `plum game --web`: the default macroquad-on-wasm32, the
 experimental `--renderer pixi` (PixiJS 8.22.0) and the experimental
 `--renderer gpu` (our own batcher, WebGPU with a WebGL2 fallback, no library),

plum-game/web-test/README.md CHANGED Viewed

@@ -1,14 +1,14 @@
 # plum-web-test
-Browser check for `plum game --web` builds, driven by [playwright-rs](https://crates.io/crates/playwright-rs) 0.20.
+Browser check for `plum game` builds, driven by [playwright-rs](https://crates.io/crates/playwright-rs) 0.20.
 Standalone crate (own `[workspace]`, not part of the root workspace).
-It builds `plum-cli`, exports the game with `plum game --web`, serves the output on
+It builds `plum-cli`, exports the game with `plum game -o`, serves the output on
-127.0.0.1:0, opens it in headless Chromium, clicks the canvas once, then asserts:
+127.0.0.1:0, opens it in headless Chromium (software WebGPU), clicks the canvas once, then asserts:
-the canvas is not one uniform colour, two screenshots 1 s apart differ (the game
-animates), and there are no page errors or console errors (except the known harmless
+the page set `plumRenderer` (WebGPU started), the canvas is not one uniform colour, two
-macroquad `register_plugin is not defined`). AudioContext state is reported; a missing
+screenshots 1 s apart differ (the game animates), and there are no page or console errors.
-running context is only a warning unless `--require-audio` is given.
+AudioContext state is reported; a missing running context is only a warning unless
+`--require-audio` is given.
 ## One-time setup
@@ -21,8 +21,8 @@ Downloads the Chromium build matching the bundled Playwright driver (about 100 M
     cargo run --manifest-path plum-game/web-test/Cargo.toml -- plum-examples/game.plum --screenshot /tmp/orb-run.png
-Options: `--frames-wait SECS` (default 8), `--screenshot OUT.png`, `--require-audio`, `--renderer pixi|macroquad|gpu` (default macroquad), `--json` (adds a one-line JSON object with the renderer, backend and frame stats), `--headed` (a real GPU window instead of headless software GL), `--measure SECS` (records requestAnimationFrame intervals in the page and prints avg / p50 / p95 / p99 ms, fps, the renderer from `plumRenderer` and the mean per-frame update/draw/render split; `--json` adds `update_ms`, `draw_ms`, `render_ms`) and `--uncapped` (lifts vsync so the frame time is the work per frame). `fixtures/stress.plum` is the scene behind [BENCHMARK.md](BENCHMARK.md).
+Options: `--frames-wait SECS` (default 8), `--screenshot OUT.png`, `--assets DIR` (default: `assets` beside the source), `--require-audio`, `--json` (adds a one-line JSON object with the backend and frame stats), `--headed` (a real GPU window instead of headless software WebGPU), `--measure SECS` (records requestAnimationFrame intervals in the page and prints avg / p50 / p95 / p99 ms, fps and the mean per-frame update/draw/render split; `--json` adds `update_ms`, `draw_ms`, `render_ms`) and `--uncapped` (lifts vsync so the frame time is the work per frame). `fixtures/stress.plum` and `fixtures/stress_scene.plum` are the scenes behind [BENCHMARK.md](BENCHMARK.md).
 Exit code is non-zero with a message on failure.
 `cargo test --manifest-path plum-game/web-test/Cargo.toml` runs the same check on
-`plum-examples/game.plum` with both renderers; it skips with a note if Chromium is not installed.
+`plum-examples/game.plum` and `plum-examples/scene.plum`; it skips with a note if Chromium is not installed.

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

@@ -1,4 +1,4 @@
-//! Browser check for `plum game --web` builds, driven by playwright-rs.
+//! Browser check for `plum game` builds, driven by playwright-rs.
 use playwright_rs::{LaunchOptions, Playwright};
 use std::io::{Read, Write};
 use std::net::{TcpListener, TcpStream};
@@ -8,34 +8,17 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
-/// The browser renderer of the web build under test.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Renderer {
-    Macroquad,
-    Pixi,
-    Gpu,
-}
-impl Renderer {
-    pub fn name(self) -> &'static str {
-        match self {
-            Renderer::Macroquad => "macroquad",
-            Renderer::Pixi => "pixi",
-            Renderer::Gpu => "gpu",
-        }
-    }
-}
 pub struct Options {
     pub frames_wait: f64,
     pub screenshot: Option<PathBuf>,
     pub require_audio: bool,
+    /// Asset directory passed to `plum game --assets` (default: `assets` beside the source).
-    pub renderer: Renderer,
+    pub assets: Option<PathBuf>,
-    /// A real (GPU) browser window instead of headless software GL.
+    /// A real (GPU) browser window instead of headless software WebGPU.
     pub headed: bool,
     /// Record requestAnimationFrame intervals for this many seconds and report them.
     pub measure: Option<f64>,
-    /// Append a one-line JSON object with the renderer and frame statistics to the report.
+    /// Append a one-line JSON object with the frame statistics to the report.
     pub json: bool,
     /// Lift Chromium's vsync / frame-rate cap so frame times show the work per frame.
     pub uncapped: bool,
@@ -47,7 +30,7 @@ impl Default for Options {
             frames_wait: 8.0,
             screenshot: None,
             require_audio: false,
-            renderer: Renderer::Macroquad,
+            assets: None,
             headed: false,
             measure: None,
             json: false,
@@ -88,28 +71,26 @@ fn json_str(s: &str) -> String {
 }
 /// Mean per-frame phase times (ms) from the in-page `__plumMeasure` counters.
-/// `render_ms` is None where the renderer cannot separate it (macroquad).
 #[derive(Debug, PartialEq)]
 pub struct Phases {
     pub update_ms: f64,
     pub draw_ms: f64,
-    pub render_ms: Option<f64>,
+    pub render_ms: f64,
 }
 /// Phases from the page counters `{n, u, d, r}` (frames, summed update/draw/render ms).
-pub fn phases_from(c: &[f64], has_render: bool) -> Option<Phases> {
+pub fn phases_from(c: &[f64]) -> Option<Phases> {
     if c.len() < 4 || c[0] < 1.0 {
         return None;
     }
-    Some(Phases { update_ms: c[1] / c[0], draw_ms: c[2] / c[0], render_ms: has_render.then(|| c[3] / c[0]) })
+    Some(Phases { update_ms: c[1] / c[0], draw_ms: c[2] / c[0], render_ms: c[3] / c[0] })
 }
-/// One JSON object: renderer, backend (`plumRenderer`), headed, uncapped, the frame statistics
+/// One JSON object: backend (`plumRenderer`), headed, uncapped, the frame statistics
 /// and (when measured) update_ms / draw_ms / render_ms.
 pub fn stats_json(opts: &Options, backend: Option<&str>, st: Option<&FrameStats>, ph: Option<&Phases>) -> String {
     let mut s = format!(
-        "{{\"renderer\":{},\"backend\":{},\"headed\":{},\"uncapped\":{}",
+        "{{\"backend\":{},\"headed\":{},\"uncapped\":{}",
-        json_str(opts.renderer.name()),
         backend.map(json_str).unwrap_or_else(|| "null".into()),
         opts.headed,
         opts.uncapped
@@ -123,11 +104,7 @@ pub fn stats_json(opts: &Options, backend: Option<&str>, st: Option<&FrameStats>
     }
     if let Some(ph) = ph {
         s.pop();
-        s.push_str(&format!(",\"update_ms\":{:.3},\"draw_ms\":{:.3}", ph.update_ms, ph.draw_ms));
+        s.push_str(&format!(",\"update_ms\":{:.3},\"draw_ms\":{:.3},\"render_ms\":{:.3}}}", ph.update_ms, ph.draw_ms, ph.render_ms));
-        match ph.render_ms {
-            Some(r) => s.push_str(&format!(",\"render_ms\":{r:.3}}}")),
-            None => s.push_str(",\"render_ms\":null}"),
-        }
     }
     s
 }
@@ -155,8 +132,8 @@ pub fn repo_root() -> PathBuf {
     Path::new(env!("CARGO_MANIFEST_DIR")).join("../..").canonicalize().expect("repo root")
 }
-/// Builds plum-cli and exports `file` as a web build into `out`.
+/// Builds plum-cli and exports `file` as a static web build into `out`.
-pub fn build_web(file: &Path, out: &Path, renderer: Renderer) -> Result<(), String> {
+pub fn build_web(file: &Path, out: &Path, assets: Option<&Path>) -> Result<(), String> {
     let root = repo_root();
     let st = Command::new("cargo")
         .args(["build", "-p", "plum-cli"])
@@ -167,17 +144,15 @@ pub fn build_web(file: &Path, out: &Path, renderer: Renderer) -> Result<(), Stri
         return Err("cargo build -p plum-cli failed".into());
     }
     let file = file.canonicalize().map_err(|e| format!("{}: {e}", file.display()))?;
-    let o = Command::new(root.join("target/debug/plum"))
+    let mut cmd = Command::new(root.join("target/debug/plum"));
-        .args(["game", "--web", "--renderer", renderer.name()])
+    cmd.arg("game").arg(&file).arg("-o").arg(out);
-        .arg(&file)
-        .arg("-o")
-        .arg(out)
-        .current_dir(&root)
+    if let Some(a) = assets {
-        .output()
+        cmd.arg("--assets").arg(a.canonicalize().map_err(|e| format!("{}: {e}", a.display()))?);
+    }
-        .map_err(|e| format!("plum game --web: {e}"))?;
+    let o = cmd.current_dir(&root).output().map_err(|e| format!("plum game: {e}"))?;
     if !o.status.success() {
         return Err(format!(
-            "plum game --web failed:\n{}{}",
+            "plum game failed:\n{}{}",
             String::from_utf8_lossy(&o.stdout),
             String::from_utf8_lossy(&o.stderr)
         ));
@@ -305,7 +280,7 @@ pub async fn run(file: &Path, opts: &Options) -> Result<String, String> {
 }
 async fn run_in(file: &Path, opts: &Options, dir: &Path) -> Result<String, String> {
-    build_web(file, dir, opts.renderer)?;
+    build_web(file, dir, opts.assets.as_deref())?;
     let stop = Arc::new(AtomicBool::new(false));
     let port = serve(dir.to_path_buf(), stop.clone());
     let res = check(port, opts).await;
@@ -321,12 +296,10 @@ fn pe<E: std::fmt::Display>(what: &'static str) -> impl FnOnce(E) -> String {
 async fn check(port: u16, opts: &Options) -> Result<String, String> {
     let pw = Playwright::launch().await.map_err(pe("launch playwright"))?;
     let mut args: Vec<String> = ["--ignore-gpu-blocklist", "--autoplay-policy=no-user-gesture-required"].map(String::from).to_vec();
+    // The renderer is WebGPU only: headless Chromium needs a software adapter.
+    args.extend(["--enable-unsafe-webgpu", "--enable-features=Vulkan"].map(String::from));
     if !opts.headed {
-        args.extend(["--use-angle=swiftshader", "--enable-unsafe-swiftshader"].map(String::from));
-        if opts.renderer == Renderer::Gpu {
-            // The gpu renderer is WebGPU only: give headless Chromium a software adapter.
-            args.extend(["--enable-unsafe-webgpu", "--enable-features=Vulkan", "--use-webgpu-adapter=swiftshader"].map(String::from));
+        args.extend(["--use-angle=swiftshader", "--enable-unsafe-swiftshader", "--use-webgpu-adapter=swiftshader"].map(String::from));
-        }
     }
     if opts.uncapped {
         args.extend(["--disable-gpu-vsync", "--disable-frame-rate-limit"].map(String::from));
@@ -348,7 +321,7 @@ async fn check_page(browser: &playwright_rs::protocol::Browser, port: u16, opts:
             let (errors, logs) = (errors.clone(), logs.clone());
             async move {
                 let line = format!("console.{}: {}", m.type_(), m.text());
-                if m.type_() == "error" && !m.text().contains("register_plugin is not defined") {
+                if m.type_() == "error" {
                     errors.lock().unwrap().push(line.clone());
                 }
                 logs.lock().unwrap().push(line);
@@ -363,9 +336,7 @@ async fn check_page(browser: &playwright_rs::protocol::Browser, port: u16, opts:
         page.on_pageerror(move |m| {
             let errors = errors.clone();
             async move {
-                if !m.contains("register_plugin is not defined") {
-                    errors.lock().unwrap().push(format!("pageerror: {m}"));
+                errors.lock().unwrap().push(format!("pageerror: {m}"));
-                }
                 Ok(())
             }
         })
@@ -403,7 +374,7 @@ async fn check_page(browser: &playwright_rs::protocol::Browser, port: u16, opts:
             .evaluate("() => { const m = window.__plumMeasure; window.__plumMeasure = null; return m ? [m.n, m.u, m.d, m.r] : []; }", None::<&()>)
             .await
             .unwrap_or_default();
-        phases = phases_from(&c, opts.renderer != Renderer::Macroquad);
+        phases = phases_from(&c);
     }
     let png1 = page.screenshot(None).await.map_err(pe("screenshot"))?;
@@ -428,8 +399,7 @@ async fn check_page(browser: &playwright_rs::protocol::Browser, port: u16, opts:
         if audio.is_empty() { "no AudioContext created".to_string() } else { format!("AudioContext states {audio:?}") },
     );
     report.push_str(&format!(
-        "\nrenderer: {} ({}, {})",
+        "\nrenderer: {}, {}",
-        opts.renderer.name(),
         renderer.as_deref().map(|r| format!("plumRenderer={r}")).unwrap_or_else(|| "plumRenderer not set".into()),
         if opts.headed { "headed" } else { "headless" },
     ));
@@ -449,7 +419,7 @@ async fn check_page(browser: &playwright_rs::protocol::Browser, port: u16, opts:
                 "\nphases per frame: update {:.3} ms, draw {:.3} ms, render {}",
                 ph.update_ms,
                 ph.draw_ms,
-                ph.render_ms.map(|r| format!("{r:.3} ms")).unwrap_or_else(|| "n/a".into())
+                format!("{:.3} ms", ph.render_ms)
             ));
         }
     } else if opts.measure.is_some() {
@@ -459,8 +429,8 @@ async fn check_page(browser: &playwright_rs::protocol::Browser, port: u16, opts:
         report.push_str(&format!("\n{}", stats_json(opts, renderer.as_deref(), measured.as_ref(), phases.as_ref())));
     }
     let mut failures = vec![];
-    if matches!(opts.renderer, Renderer::Pixi | Renderer::Gpu) && renderer.is_none() {
+    if renderer.is_none() {
-        failures.push(format!("{} build did not set globalThis.plumRenderer", opts.renderer.name()));
+        failures.push("the page did not set globalThis.plumRenderer (WebGPU failed to start?)".to_string());
     }
     if colours <= 1 {
         failures.push("canvas is blank (uniformly one colour)".to_string());

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

@@ -1,7 +1,7 @@
-use plum_web_test::{chromium_installed, run, Options, Renderer};
+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  [--renderer pixi|macroquad|gpu] [--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]";
 #[tokio::main]
 async fn main() {
@@ -19,14 +19,7 @@ async fn main() {
             "--uncapped" => opts.uncapped = true,
             "--json" => opts.json = true,
             "--measure" => opts.measure = Some(args.next().and_then(|v| v.parse().ok()).unwrap_or_else(|| fail("--measure needs a number of seconds"))),
-            "--renderer" => {
-                opts.renderer = match args.next().as_deref() {
-                    Some("pixi") => Renderer::Pixi,
-                    Some("gpu") => Renderer::Gpu,
-                    Some("macroquad") => Renderer::Macroquad,
-                    _ => fail("--renderer needs pixi, macroquad or gpu"),
+            "--assets" => opts.assets = Some(args.next().map(PathBuf::from).unwrap_or_else(|| fail("--assets needs a directory"))),
-                }
-            }
             "-h" | "--help" => {
                 println!("{USAGE}");
                 return;

plum-game/web-test/tests/web_check.rs CHANGED Viewed

@@ -1,40 +1,35 @@
-use plum_web_test::{chromium_installed, repo_root, run, Options, Renderer};
+use plum_web_test::{chromium_installed, repo_root, run, Options};
 #[test]
 fn orb_run_renders_and_animates() {
-    orb_run(Renderer::Macroquad);
+    orb_run("plum-examples/game.plum");
 }
 #[test]
-fn orb_run_renders_and_animates_on_pixi() {
-    orb_run(Renderer::Pixi);
-}
-#[test]
-fn orb_run_renders_and_animates_on_gpu() {
+fn scene_run_renders_and_animates() {
-    orb_run(Renderer::Gpu);
+    orb_run("plum-examples/scene.plum");
 }
 #[test]
 fn stats_json_is_one_object() {
     use plum_web_test::{stats_json, FrameStats, Options};
     let st = FrameStats { frames: 3, avg: 2.0, p50: 2.0, p95: 3.0, p99: 3.0 };
-    let o = Options { renderer: Renderer::Gpu, headed: true, ..Options::default() };
+    let o = Options { headed: true, ..Options::default() };
     assert_eq!(
         stats_json(&o, Some("gpu-webgpu"), Some(&st), None),
-        r#"{"renderer":"gpu","backend":"gpu-webgpu","headed":true,"uncapped":false,"frames":3,"avg_ms":2.000,"p50_ms":2.000,"p95_ms":3.000,"p99_ms":3.000,"fps":500.00}"#
+        r#"{"backend":"gpu-webgpu","headed":true,"uncapped":false,"frames":3,"avg_ms":2.000,"p50_ms":2.000,"p95_ms":3.000,"p99_ms":3.000,"fps":500.00}"#
     );
-    assert_eq!(stats_json(&o, None, None, None), r#"{"renderer":"gpu","backend":null,"headed":true,"uncapped":false}"#);
+    assert_eq!(stats_json(&o, None, None, None), r#"{"backend":null,"headed":true,"uncapped":false}"#);
 }
-fn orb_run(renderer: Renderer) {
+fn orb_run(example: &str) {
     if !chromium_installed() {
         eprintln!("SKIP: Playwright Chromium not installed (see plum-game/web-test/README.md)");
         return;
     }
     let rt = tokio::runtime::Runtime::new().unwrap();
-    let file = repo_root().join("plum-examples/game.plum");
+    let file = repo_root().join(example);
-    let report = rt.block_on(run(&file, &Options { renderer, ..Options::default() })).unwrap_or_else(|e| panic!("{e}"));
+    let report = rt.block_on(run(&file, &Options::default())).unwrap_or_else(|e| panic!("{e}"));
     println!("{report}");
 }
@@ -64,11 +59,9 @@ fn frame_stats_are_percentiles_of_the_gaps() {
 #[test]
 fn phases_in_json() {
     use plum_web_test::{phases_from, stats_json, Options};
-    let ph = phases_from(&[10.0, 5.0, 20.0, 3.0], true).unwrap();
+    let ph = phases_from(&[10.0, 5.0, 20.0, 3.0]).unwrap();
-    assert_eq!((ph.update_ms, ph.draw_ms, ph.render_ms), (0.5, 2.0, Some(0.3)));
+    assert_eq!((ph.update_ms, ph.draw_ms, ph.render_ms), (0.5, 2.0, 0.3));
-    assert!(phases_from(&[0.0, 0.0, 0.0, 0.0], true).is_none());
+    assert!(phases_from(&[0.0, 0.0, 0.0, 0.0]).is_none());
     let j = stats_json(&Options::default(), None, None, Some(&ph));
     assert!(j.ends_with(r#","update_ms":0.500,"draw_ms":2.000,"render_ms":0.300}"#), "{j}");
-    let mq = phases_from(&[10.0, 5.0, 20.0, 0.0], false).unwrap();
-    assert!(stats_json(&Options::default(), None, None, Some(&mq)).ends_with(r#""render_ms":null}"#));
 }