bd86de6 | plum | pyrossh

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

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

bd86de6 — Peter John 2026-11-02T17:31:11+05:30

textureCreate, renderTarget, blendMode (Blend) in std/Game, the bridge and the headless runner; rendertarget fixture; web-test --expect-pixel

Files changed (11) hide show

plum-game/src/api.rs +44 -1
plum-game/src/host.rs +3 -0
plum-game/src/recorder.rs +11 -0
plum-game/tests/fixtures/target_fixture.plum +25 -0
plum-game/tests/host_test.rs +26 -0
plum-game/web-test/fixtures/rendertarget.plum +49 -0
plum-game/web-test/src/lib.rs +46 -0
plum-game/web-test/src/main.rs +6 -2
plum-game/web-test/tests/web_check.rs +30 -0
plum-game/web/plum_bridge.js +193 -72
plum-std/Game.plum +24 -0

plum-game/src/api.rs CHANGED Viewed

@@ -9,6 +9,13 @@ use std::path::{Component, Path, PathBuf};
 pub type Color = [f32; 4];
+/// The largest side of a texture made by `texture_create`.
+pub const MAX_TEXTURE_SIZE: i32 = 8192;
+pub const BLEND_NORMAL: i32 = 0;
+pub const BLEND_ADD: i32 = 1;
+pub const BLEND_MULTIPLY: i32 = 2;
+pub const BLEND_SCREEN: i32 = 3;
 pub trait Backend: 'static {
     fn screen_width(&mut self) -> f32;
     fn screen_height(&mut self) -> f32;
@@ -27,6 +34,14 @@ pub trait Backend: 'static {
     fn texture_width(&mut self, t: i32) -> i32;
     fn texture_height(&mut self, t: i32) -> i32;
     fn texture_set_smooth(&mut self, t: i32, smooth: bool);
+    /// A blank texture of `w` x `h` pixels to draw into; `-1` when a side is
+    /// below 1 or above [`MAX_TEXTURE_SIZE`].
+    fn texture_create(&mut self, w: i32, h: i32) -> i32;
+    /// Sends the following draws into the texture `t` made by `texture_create`,
+    /// or to the screen for `-1`; any other handle is ignored.
+    fn render_target(&mut self, t: i32);
+    /// Sets the blend mode (`BLEND_NORMAL`..`BLEND_SCREEN`); other values are ignored.
+    fn blend_mode(&mut self, m: i32);
     fn draw_texture(&mut self, t: i32, x: f32, y: f32, tint: Color);
     /// Draws the source rect `(sx, sy, sw, sh)` (texture pixels) into the dest
     /// rect `(x, y, w, h)`, rotated `rotation` radians clockwise about the dest
@@ -82,6 +97,8 @@ struct Tex {
     width: u32,
     height: u32,
     smooth: bool,
+    /// Made by `texture_create`, so it can be a render target.
+    target: bool,
 }
 /// Files, texture sizes and sound handles from an asset root, addressed by
@@ -142,7 +159,7 @@ impl AssetStore {
         let dims = image::io::Reader::new(std::io::Cursor::new(&bytes)).with_guessed_format().ok().and_then(|r| r.into_dimensions().ok());
         match dims {
             Some((width, height)) => {
-                self.textures.push(Tex { width, height, smooth: false });
+                self.textures.push(Tex { width, height, smooth: false, target: false });
                 self.textures.len() as i32 - 1
             }
             None => -1,
@@ -177,6 +194,20 @@ impl AssetStore {
         self.sounds.get(usize::try_from(s).ok()?).map(String::as_str)
     }
+    /// A blank render-target texture; `-1` for a side outside 1..=MAX_TEXTURE_SIZE.
+    pub fn texture_create(&mut self, w: i32, h: i32) -> i32 {
+        if !(1..=MAX_TEXTURE_SIZE).contains(&w) || !(1..=MAX_TEXTURE_SIZE).contains(&h) {
+            return -1;
+        }
+        self.textures.push(Tex { width: w as u32, height: h as u32, smooth: false, target: true });
+        self.textures.len() as i32 - 1
+    }
+    /// Whether `t` is a texture made by `texture_create`.
+    pub fn is_target(&self, t: i32) -> bool {
+        self.tex(t).is_some_and(|t| t.target)
+    }
     fn tex(&self, t: i32) -> Option<&Tex> {
         self.textures.get(usize::try_from(t).ok()?)
     }
@@ -263,6 +294,18 @@ mod tests {
         let _ = std::fs::remove_dir_all(&dir);
     }
+    #[test]
+    fn created_textures_are_targets_with_a_size() {
+        let mut s = AssetStore::new(PathBuf::from("/nonexistent-plum-assets"));
+        assert_eq!(s.texture_create(0, 4), -1);
+        assert_eq!(s.texture_create(4, 8193), -1);
+        let t = s.texture_create(32, 16);
+        assert_eq!((s.texture_width(t), s.texture_height(t)), (32, 16));
+        assert!(s.is_target(t));
+        assert!(!s.is_target(-1));
+        assert!(!s.is_target(t + 1));
+    }
     #[test]
     fn paths_escaping_the_root_are_rejected() {
         for bad in ["../x", "a/../../x", "/etc/passwd", "a\\b", ""] {

plum-game/src/host.rs CHANGED Viewed

@@ -112,6 +112,9 @@ fn dispatch<B: Backend>(name: &str, caller: &mut Caller<'_, HostState<B>>, p: &[
         "textureWidth" => r[0] = Val::I32(b!().texture_width(int(p, 0))),
         "textureHeight" => r[0] = Val::I32(b!().texture_height(int(p, 0))),
         "textureSetSmooth" => b!().texture_set_smooth(int(p, 0), int(p, 1) != 0),
+        "textureCreate" => r[0] = Val::I32(b!().texture_create(int(p, 0), int(p, 1))),
+        "renderTarget" => b!().render_target(int(p, 0)),
+        "blendMode" => b!().blend_mode(int(p, 0)),
         "drawTexture" => b!().draw_texture(int(p, 0), f(p, 1), f(p, 2), color(p, 3)),
         "drawTextureEx" => b!().draw_texture_ex(
             int(p, 0),

plum-game/src/recorder.rs CHANGED Viewed

@@ -105,6 +105,17 @@ impl Backend for Recorder {
         self.rec(format!("textureSetSmooth({t},{smooth})"));
         self.assets.texture_set_smooth(t, smooth);
     }
+    fn texture_create(&mut self, w: i32, h: i32) -> i32 {
+        let t = self.assets.texture_create(w, h);
+        self.rec(format!("textureCreate({w},{h}) -> {t}"));
+        t
+    }
+    fn render_target(&mut self, t: i32) {
+        self.rec(format!("renderTarget({t})"));
+    }
+    fn blend_mode(&mut self, m: i32) {
+        self.rec(format!("blendMode({m})"));
+    }
     fn draw_texture(&mut self, t: i32, x: f32, y: f32, tint: Color) {
         self.rec(format!("drawTexture({t},{x},{y},{})", c4(tint)));
     }

plum-game/tests/fixtures/target_fixture.plum ADDED Viewed

@@ -0,0 +1,25 @@
+module target_fixture
+import std/Int
+import std/Float
+import std/Str
+import std/Vec2
+import std/Color
+import std/Game
+record State(canvas: Int, bad: Int)
+export fun init() -> State =
+  State(canvas: textureCreate(64, 32), bad: textureCreate(0, 5))
+export fun update(g: State, dt: Float) =
+  g.canvas = g.canvas
+export fun draw(g: State) =
+  renderTarget(g.canvas)
+  clear(Color.Transparent)
+  drawRect(0.0, 0.0, 10.0, 10.0, Color.Red)
+  renderTarget(-1)
+  blendMode(Blend.Add)
+  drawTexture(g.canvas, 20.0, 20.0, Color.White)
+  blendMode(Blend.Normal)
+  drawText("size {textureWidth(g.canvas)}x{textureHeight(g.canvas)} bad {g.bad}", 0.0, 0.0, 8.0, Color.White)

plum-game/tests/host_test.rs CHANGED Viewed

@@ -262,3 +262,29 @@ fn sceneExampleRunsFrames() {
     g.draw().expect("draw");
     assert!(g.backend().calls.iter().any(|c| c.starts_with("draw")), "{:?}", g.backend().calls);
 }
+#[test]
+fn renderTargetAndBlendCallsAreRecorded() {
+    let wasm = compile(&Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/target_fixture.plum"));
+    let mut g = PlumGame::load(&wasm, Recorder::new()).unwrap();
+    g.init().unwrap();
+    g.draw().unwrap();
+    let calls = g.backend().calls.clone();
+    let from = calls.iter().position(|c| c == "renderTarget(0)").expect("renderTarget(0)");
+    assert_eq!(
+        calls[from..],
+        [
+            "renderTarget(0)",
+            "clear(0,0,0,0)",
+            "drawRect(0,0,10,10,1,0,0,1)",
+            "renderTarget(-1)",
+            "blendMode(1)",
+            "drawTexture(0,20,20,1,1,1,1)",
+            "blendMode(0)",
+            "textureWidth(0)",
+            "textureHeight(0)",
+            "drawText(\"size 64x32 bad -1\",0,0,8,1,1,1,1)",
+        ]
+    );
+    assert_eq!(calls[..2], ["textureCreate(64,32) -> 0", "textureCreate(0,5) -> -1"]);
+}

plum-game/web-test/fixtures/rendertarget.plum ADDED Viewed

@@ -0,0 +1,49 @@
+# Render targets and blend modes, checked by pixel (see the --expect-pixel flags in
+# web-test/tests/web_check.rs). The background is (51,51,51).
+#  1. a 64x64 target drawn with red and green squares, shown through a camera
+#     (10,0) x2: red at (100..164, 100..164), green at (164..228, 164..228), the
+#     transparent rest shows the background; the target's own camera is pixels
+#  2. Add (400,100): rgb(0.2,0.4,0.6) over the background gives (102,153,204)
+#  3. Multiply (550,100): rgb(0.5,1,0.5) gives (26,51,26)
+#  4. Screen (700,100): rgb(0.5,0.5,0.5) gives (153,153,153)
+#  5. Normal with alpha 0.5 (850,100): red gives (153,26,26)
+#  6. a second 16x16 blue target drawn at (400,300)
+module rendertarget
+import std/Str
+import std/Int
+import std/Float
+import std/Vec2
+import std/Color
+import std/Game
+record Targets(big: Int, small: Int, t: Int)
+export fun init() -> Targets =
+  Targets(big: textureCreate(64, 64), small: textureCreate(16, 16), t: 0)
+export fun update(g: Targets, dt: Float) =
+  g.t = g.t + 1
+export fun draw(g: Targets) =
+  setCamera(10.0, 0.0, 2.0)
+  renderTarget(g.big)
+  clear(Color.Transparent)
+  drawRect(0.0, 0.0, 32.0, 32.0, Color.rgb(1.0, 0.0, 0.0))
+  drawRect(32.0, 32.0, 32.0, 32.0, Color.rgb(0.0, 1.0, 0.0))
+  renderTarget(g.small)
+  clear(Color.rgb(0.0, 0.0, 1.0))
+  renderTarget(-1)
+  clear(Color.rgb(0.2, 0.2, 0.2))
+  drawTexture(g.big, 60.0, 50.0, Color.White)
+  resetCamera()
+  blendMode(Blend.Add)
+  drawRect(400.0, 100.0, 100.0, 100.0, Color.rgb(0.2, 0.4, 0.6))
+  blendMode(Blend.Multiply)
+  drawRect(550.0, 100.0, 100.0, 100.0, Color.rgb(0.5, 1.0, 0.5))
+  blendMode(Blend.Screen)
+  drawRect(700.0, 100.0, 100.0, 100.0, Color.rgb(0.5, 0.5, 0.5))
+  blendMode(Blend.Normal)
+  drawRect(850.0, 100.0, 100.0, 100.0, Color(r: 1.0, g: 0.0, b: 0.0, a: 0.5))
+  drawTexture(g.small, 400.0, 300.0, Color.White)
+  drawText("frame {g.t}", 20.0, 500.0, 16.0, Color.White)
+  drawRect(Float(g.t % 600), 600.0, 40.0, 6.0, Color.Yellow)

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

@@ -24,6 +24,8 @@ pub struct Options {
     pub uncapped: bool,
     /// Browser `devicePixelRatio` (Playwright `deviceScaleFactor`); the page default when None.
     pub dpr: Option<f64>,
+    /// Colours the final screenshot must have at CSS pixel (x, y): each is x, y, [r, g, b], tolerance.
+    pub expect_pixels: Vec<ExpectPixel>,
     /// Destroy the GPU device from the page after a few frames and require rendering to resume.
     pub lose_device: bool,
 }
@@ -41,6 +43,45 @@ impl Default for Options {
             uncapped: false,
             dpr: None,
             lose_device: false,
+            expect_pixels: Vec::new(),
+        }
+    }
+}
+/// `--expect-pixel x,y,r,g,b[,tol]`: the screenshot pixel at CSS (x, y) is within `tol`
+/// (default 2) of (r, g, b) on every channel.
+#[derive(Debug, Clone, PartialEq)]
+pub struct ExpectPixel {
+    pub x: u32,
+    pub y: u32,
+    pub rgb: [u8; 3],
+    pub tol: u8,
+}
+impl ExpectPixel {
+    pub fn parse(s: &str) -> Result<ExpectPixel, String> {
+        let n: Vec<u32> = s.split(',').map(|p| p.trim().parse::<u32>().map_err(|_| format!("--expect-pixel {s}: '{p}' is not a number"))).collect::<Result<_, _>>()?;
+        if n.len() != 5 && n.len() != 6 {
+            return Err(format!("--expect-pixel {s}: expected x,y,r,g,b[,tol]"));
+        }
+        if n[2..5].iter().any(|c| *c > 255) || n.get(5).is_some_and(|t| *t > 255) {
+            return Err(format!("--expect-pixel {s}: channels and tolerance are 0..255"));
+        }
+        Ok(ExpectPixel { x: n[0], y: n[1], rgb: [n[2] as u8, n[3] as u8, n[4] as u8], tol: n.get(5).map_or(2, |t| *t as u8) })
+    }
+    /// An error message when `shot` (taken at `dpr` device pixels per CSS pixel) differs.
+    pub fn check(&self, shot: &Shot, dpr: f64) -> Option<String> {
+        let (px, py) = ((f64::from(self.x) * dpr) as u32, (f64::from(self.y) * dpr) as u32);
+        if px >= shot.w || py >= shot.h {
+            return Some(format!("--expect-pixel {},{}: outside the {}x{} screenshot", self.x, self.y, shot.w, shot.h));
+        }
+        let i = ((py * shot.w + px) * 4) as usize;
+        let got = [shot.rgba[i], shot.rgba[i + 1], shot.rgba[i + 2]];
+        if got.iter().zip(self.rgb).all(|(g, w)| g.abs_diff(w) <= self.tol) {
+            None
+        } else {
+            Some(format!("--expect-pixel {},{}: expected {:?} (tolerance {}), screenshot has {:?}", self.x, self.y, self.rgb, self.tol, got))
         }
     }
 }
@@ -491,6 +532,11 @@ async fn check_page(browser: &playwright_rs::protocol::Browser, port: u16, opts:
     }
     let mut failures = failures_pre;
     failures.extend(loss_failure);
+    let dpr = backing.get(2).copied().unwrap_or(1.0);
+    failures.extend(opts.expect_pixels.iter().filter_map(|e| e.check(&b, dpr)));
+    if !opts.expect_pixels.is_empty() {
+        report.push_str(&format!("\npixel checks: {}", opts.expect_pixels.len()));
+    }
     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,8 +1,8 @@
-use plum_web_test::{chromium_installed, run, Options};
+use plum_web_test::{chromium_installed, run, ExpectPixel, 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]
-  [--dpr N] [--lose-device]";
+  [--dpr N] [--lose-device] [--expect-pixel x,y,r,g,b[,tol]]...";
 #[tokio::main]
 async fn main() {
@@ -19,6 +19,10 @@ async fn main() {
             "--headed" => opts.headed = true,
             "--uncapped" => opts.uncapped = true,
             "--json" => opts.json = true,
+            "--expect-pixel" => {
+                let v = args.next().unwrap_or_else(|| fail("--expect-pixel needs x,y,r,g,b[,tol]"));
+                opts.expect_pixels.push(ExpectPixel::parse(&v).unwrap_or_else(|e| fail(&e)));
+            }
             "--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"))),

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

@@ -74,3 +74,33 @@ fn draws_in_json() {
     let j = stats_json(&Options::default(), None, None, Some(&ph));
     assert!(j.ends_with(r#","render_ms":0.300,"draws":2.50}"#), "{j}");
 }
+#[test]
+fn expect_pixel_parses_and_checks() {
+    use plum_web_test::{ExpectPixel, Shot};
+    let e = ExpectPixel::parse("1,0,10,20,30").unwrap();
+    assert_eq!((e.x, e.y, e.rgb, e.tol), (1, 0, [10, 20, 30], 2));
+    assert_eq!(ExpectPixel::parse("1,0,10,20,30,5").unwrap().tol, 5);
+    assert!(ExpectPixel::parse("1,0,10").is_err());
+    assert!(ExpectPixel::parse("1,0,10,20,300").is_err());
+    let shot = Shot { w: 2, h: 1, rgba: vec![0, 0, 0, 255, 10, 21, 30, 255] };
+    assert!(e.check(&shot, 1.0).is_none());
+    assert!(ExpectPixel::parse("1,0,10,25,30").unwrap().check(&shot, 1.0).unwrap().contains("screenshot has [10, 21, 30]"));
+    assert!(ExpectPixel::parse("1,0,0,0,0").unwrap().check(&shot, 1.0).is_some());
+    // CSS (0, 0) at dpr 2 is device pixel (0, 0); CSS (1, 0) would be device (2, 0): outside.
+    assert!(e.check(&shot, 2.0).unwrap().contains("outside"));
+}
+#[test]
+fn render_target_pixels() {
+    if !chromium_installed() {
+        eprintln!("SKIP: Playwright Chromium not installed (see plum-game/web-test/README.md)");
+        return;
+    }
+    let pixels = ["130,130,255,0,0", "196,196,0,255,0", "130,196,51,51,51", "450,150,102,153,204", "600,150,26,51,26", "750,150,153,153,153", "900,150,153,26,26", "408,308,0,0,255"];
+    let opts = Options { expect_pixels: pixels.iter().map(|p| plum_web_test::ExpectPixel::parse(p).unwrap()).collect(), ..Options::default() };
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    let file = repo_root().join("plum-game/web-test/fixtures/rendertarget.plum");
+    let report = rt.block_on(run(&file, &opts)).unwrap_or_else(|e| panic!("{e}"));
+    println!("{report}");
+}

plum-game/web/plum_bridge.js CHANGED Viewed

@@ -15,6 +15,7 @@
   "use strict";
   const IMAGE_EXT = /\.(png|jpe?g|gif|webp|bmp)$/i;
+  const MAX_TEXTURE = 8192; // WebGPU's default maxTextureDimension2D
   const SOUND_EXT = /\.(wav|ogg)$/i;
   // --- paths --------------------------------------------------------------------
@@ -284,7 +285,10 @@
     let idx = new Uint32Array(icap);
     let vn = 0; // vertices used
     let inn = 0; // indices used
-    const batches = []; // pooled { id, slots, n, start, count }
+    // Pooled draw/clear items in call order: { id, slots, n, start, count, blend, target, clear }.
+    // A draw item holds up to 16 textures; `target` is the render-target texture
+    // (null for the screen) and `clear` is null, or [r, g, b, a] for a clear of `target`.
+    const batches = [];
     let nb = 0;
     let cur = null;
     let batchSeq = 0;
@@ -301,7 +305,10 @@
     let bx = -1;
     let my = -2;
     let by = 1;
+    let curTarget = null; // render-target texture being drawn into; null = the screen
+    let curBlend = 0;
+    let scr = { w: 1, h: 1, dpr: 1 }; // the screen's size and ratio, kept while a target is selected
-    const clearColor = [0, 0, 0, 1];
+    const screenCam = { x: 0, y: 0, s: 1 };
     function reserve(nv, ni) {
       if (vn + nv > vcap) {
@@ -320,17 +327,25 @@
       }
     }
+    function newItem() {
+      let it = batches[nb];
+      if (!it) batches.push((it = { id: 0, slots: new Array(SLOTS).fill(null), n: 0, start: 0, count: 0, blend: 0, target: null, clear: null }));
+      nb++;
+      it.id = ++batchSeq;
+      it.start = inn;
+      it.blend = curBlend;
+      it.target = curTarget;
+      it.clear = null;
+      it.n = 0;
+      it.count = 0;
+      return it;
+    }
     // Puts `t` in a slot of the current batch; starts a new batch when all 16 slots
     // hold other textures. Sets slotBits for the vertices that follow.
     function useTex(t) {
-      if (!cur || (t.bid !== cur.id && cur.n === SLOTS)) {
+      if (!cur || cur.target !== curTarget || cur.blend !== curBlend || (t.bid !== cur.id && cur.n === SLOTS)) {
-        cur = batches[nb];
+        cur = newItem();
-        if (!cur) batches.push((cur = { id: 0, slots: new Array(SLOTS).fill(null), n: 0, start: 0, count: 0 }));
-        nb++;
-        cur.id = ++batchSeq;
-        cur.n = 0;
-        cur.start = inn;
-        cur.count = 0;
       }
       if (t.bid !== cur.id) {
         t.bid = cur.id;
@@ -353,6 +368,7 @@
     // Corners in order: top-left, top-right, bottom-right, bottom-left.
     function quad(t, ax, ay, bx_, by_, cx, cy, dx, dy, u0, v0, u1, v1, c) {
+      if (t === curTarget) return; // a target cannot be drawn into itself
       reserve(4, 6);
       useTex(t);
       const base = vn;
@@ -385,9 +401,10 @@
       newTextureId: () => texSeq++,
       white,
       cam,
-      clearColor,
-      // Per-frame state; (w, h) is the screen size in CSS pixels.
+      // Per-frame state; (w, h) is the screen size in CSS pixels. Every frame
+      // starts on the screen with the normal blend mode and a default camera.
       beginFrame(w, h, ratio) {
+        scr = { w, h, dpr: ratio };
         sw = w;
         sh = h;
         dpr = ratio;
@@ -395,8 +412,8 @@
         inn = 0;
         nb = 0;
         cur = null;
-        clearColor[0] = clearColor[1] = clearColor[2] = 0;
+        curTarget = null;
-        clearColor[3] = 1;
+        curBlend = 0;
         setCamera(0, 0, 1);
       },
       get f32() { return f32; },
@@ -405,16 +422,42 @@
       get indexCount() { return inn; },
       get batchCount() { return nb; },
       batches,
-      // Everything drawn so far this frame is discarded, as clearing the screen does.
+      // Fills the current target (the screen by default); earlier draws into it are overwritten.
       clear(r, g, b, a) {
-        vn = 0;
-        inn = 0;
-        nb = 0;
         cur = null;
+        newItem().clear = [clamp01(r), clamp01(g), clamp01(b), clamp01(a)];
+      },
+      // Following draws go into render-target texture `h`, or the screen for -1. A
+      // target's camera starts as the identity over its pixels. A handle that is not
+      // a texture made by textureCreate is ignored.
+      renderTarget(h) {
+        let t = null;
+        if (h !== -1) {
+          t = textures[h];
+          if (!t || !t.target) return;
+        }
+        if (t === curTarget && t === null) return;
+        if (curTarget === null) {
-        clearColor[0] = clamp01(r);
+          screenCam.x = cam.x;
-        clearColor[1] = clamp01(g);
+          screenCam.y = cam.y;
-        clearColor[2] = clamp01(b);
+          screenCam.s = cam.s;
+        }
+        curTarget = t;
+        if (t) {
+          sw = t.w;
+          sh = t.h;
+          dpr = 1;
-        clearColor[3] = clamp01(a);
+          setCamera(0, 0, 1);
+        } else {
+          sw = scr.w;
+          sh = scr.h;
+          dpr = scr.dpr;
+          setCamera(screenCam.x, screenCam.y, screenCam.s);
+        }
+      },
+      // Normal 0, Add 1, Multiply 2, Screen 3; other values are ignored.
+      blendMode(m) {
+        if (m >= 0 && m <= 3) curBlend = m | 0;
       },
       drawRect(x, y, w, h, r, g, b, a) {
         quad(white, x, y, x + w, y, x + w, y + h, x, y + h, 0, 0, 1, 1, packColor(r, g, b, a));
@@ -550,7 +593,7 @@ fn pick(slot: u32, uv: vec2f) -> vec4f {
 ${cases}    default: { return vec4f(1.0); }
   }
 }
-@fragment fn fs(i: VOut) -> @location(0) vec4f {
+fn shade(i: VOut) -> vec4f {
   let fw = max(fwidth(i.uv.x), fwidth(i.uv.y));
   let texel = pick(i.slot, i.uv);
   if ((i.slot & ${SDF_BIT}u) != 0u) {
@@ -558,6 +601,19 @@ ${cases}    default: { return vec4f(1.0); }
     return vec4f(i.c.rgb, i.c.a * smoothstep(0.5 - w, 0.5 + w, texel.a));
   }
   return texel * i.c;
+}
+@fragment fn fs(i: VOut) -> @location(0) vec4f {
+  return shade(i);
+}
+// Multiply: the blend state is src * dst, so a translucent colour fades towards white.
+@fragment fn fsMultiply(i: VOut) -> @location(0) vec4f {
+  let c = shade(i);
+  return vec4f(mix(vec3f(1.0), c.rgb, c.a), c.a);
+}
+// Screen: the blend state is src * (1 - dst) + dst with a premultiplied src.
+@fragment fn fsScreen(i: VOut) -> @location(0) vec4f {
+  let c = shade(i);
+  return vec4f(c.rgb * c.a, c.a);
 }`;
   }
   const WGSL = makeWGSL();
@@ -574,8 +630,10 @@ ${cases}    default: { return vec4f(1.0); }
     if (!ctx) return null;
     const format = navigator.gpu.getPreferredCanvasFormat();
     let device = null;
-    let pipeline = null;
+    let module = null;
     let layout = null;
+    let pipelineLayout = null;
+    const pipelines = new Map(); // blend mode | format -> render pipeline
     let nearest = null;
     let linear = null;
     let vbuf = null;
@@ -590,40 +648,67 @@ ${cases}    default: { return vec4f(1.0); }
       return adapter ? adapter.requestDevice() : null;
     }
+    // Standard WebGPU blend states for Normal, Add, Multiply and Screen (the two
+    // last need the matching fragment entry point, which premixes the colour).
+    const BLENDS = [
+      {
+        color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" },
+        alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
+      },
+      {
+        color: { srcFactor: "src-alpha", dstFactor: "one", operation: "add" },
+        alpha: { srcFactor: "one", dstFactor: "one", operation: "add" },
+      },
+      {
+        color: { srcFactor: "dst", dstFactor: "zero", operation: "add" },
+        alpha: { srcFactor: "zero", dstFactor: "one", operation: "add" },
+      },
+      {
+        color: { srcFactor: "one-minus-dst", dstFactor: "one", operation: "add" },
+        alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
+      },
+    ];
+    const ENTRIES = ["fs", "fs", "fsMultiply", "fsScreen"];
+    function pipelineFor(mode, fmt) {
+      const key = mode + "|" + fmt;
+      let p = pipelines.get(key);
+      if (!p) {
+        p = device.createRenderPipeline({
+          layout: pipelineLayout,
+          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: ENTRIES[mode], targets: [{ format: fmt, blend: BLENDS[mode] }] },
+          primitive: { topology: "triangle-list" },
+        });
+        pipelines.set(key, p);
+      }
+      return p;
+    }
     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 });
+      module = device.createShaderModule({ code: WGSL });
-      pipeline = device.createRenderPipeline({
+      pipelines.clear();
-        layout: "auto",
-        vertex: {
-          module,
-          entryPoint: "vs",
-          buffers: [{
-            arrayStride: VERT_BYTES,
-            attributes: [
+      const entries = [];
-              { shaderLocation: 0, format: "float32x2", offset: 0 },
+      for (let i = 0; i < SLOTS; i++) entries.push({ binding: i, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } });
-              { 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" },
+      entries.push({ binding: 16, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } });
-              alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
+      entries.push({ binding: 17, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } });
-            },
-          }],
-        },
-        primitive: { topology: "triangle-list" },
-      });
-      layout = pipeline.getBindGroupLayout(0);
+      layout = device.createBindGroupLayout({ entries });
+      pipelineLayout = device.createPipelineLayout({ bindGroupLayouts: [layout] });
       nearest = device.createSampler({ magFilter: "nearest", minFilter: "nearest" });
       linear = device.createSampler({ magFilter: "linear", minFilter: "linear" });
       vbuf = ibuf = null;
@@ -736,30 +821,58 @@ ${cases}    default: { return vec4f(1.0); }
           device.queue.writeBuffer(vbuf, 0, b.f32.buffer, 0, vbytes);
           device.queue.writeBuffer(ibuf, 0, b.idx.buffer, 0, ibytes);
         }
+        // Items run in call order; a pass lasts while consecutive items share a target.
-        const [cr, cg, cb] = b.clearColor;
+        // The screen is cleared by its first pass (to black unless a clear comes first).
         const enc = device.createCommandEncoder();
+        let pass = null;
+        let passTarget;
+        let screenCleared = false;
+        let draws = 0;
+        const begin = (target, clearValue) => {
+          if (pass) pass.end();
+          const screen = !target;
+          const clearing = clearValue || (screen && !screenCleared ? [0, 0, 0, 1] : null);
+          if (screen) screenCleared = true;
-        const pass = enc.beginRenderPass({
+          pass = enc.beginRenderPass({
-          colorAttachments: [{
+            colorAttachments: [{
-            view: ctx.getCurrentTexture().createView(),
+              view: screen ? ctx.getCurrentTexture().createView() : target.view,
-            clearValue: { r: cr, g: cg, b: cb, a: 1 },
+              clearValue: clearing ? { r: clearing[0], g: clearing[1], b: clearing[2], a: screen ? 1 : clearing[3] } : undefined,
-            loadOp: "clear",
+              loadOp: clearing ? "clear" : "load",
-            storeOp: "store",
+              storeOp: "store",
-          }],
+            }],
-        });
+          });
+          passTarget = target;
-        if (vbytes) {
+          if (vbytes) {
-          pass.setPipeline(pipeline);
-          pass.setVertexBuffer(0, vbuf);
+            pass.setVertexBuffer(0, vbuf);
-          pass.setIndexBuffer(ibuf, "uint32");
+            pass.setIndexBuffer(ibuf, "uint32");
-          for (let i = 0; i < b.batchCount; i++) {
-            const bt = b.batches[i];
-            pass.setBindGroup(0, bindGroup(bt));
-            pass.drawIndexed(bt.count, 1, bt.start);
           }
+        };
+        let boundBlend = -1;
+        for (let i = 0; i < b.batchCount; i++) {
+          const bt = b.batches[i];
+          if (bt.clear) {
+            begin(bt.target, bt.clear);
+            boundBlend = -1;
+            continue;
+          }
+          if (bt.count === 0) continue;
+          if (!pass || passTarget !== bt.target) {
+            begin(bt.target, null);
+            boundBlend = -1;
+          }
+          if (bt.blend !== boundBlend) {
+            pass.setPipeline(pipelineFor(bt.blend, bt.target ? "rgba8unorm" : format));
+            boundBlend = bt.blend;
+          }
+          pass.setBindGroup(0, bindGroup(bt));
+          pass.drawIndexed(bt.count, 1, bt.start);
+          draws++;
         }
+        if (!screenCleared) begin(null, null);
         pass.end();
         device.queue.submit([enc.finish()]);
         globalThis.plumFrames = (globalThis.plumFrames || 0) + 1;
-        return vbytes ? b.batchCount : 0;
+        return draws;
       },
     };
   }
@@ -996,6 +1109,14 @@ ${cases}    default: { return vec4f(1.0); }
         if (!img) return -1;
         return b.textures.push(backend.createTexture(img.bitmap, img.w, img.h, false)) - 1;
       },
+      textureCreate: (w, h) => {
+        if (!(w >= 1 && h >= 1 && w <= MAX_TEXTURE && h <= MAX_TEXTURE)) return -1;
+        const t = backend.createTexture(null, w | 0, h | 0, false);
+        t.target = true;
+        return b.textures.push(t) - 1;
+      },
+      renderTarget: b.renderTarget,
+      blendMode: b.blendMode,
       textureWidth: b.textureWidth,
       textureHeight: b.textureHeight,
       textureSetSmooth: (h, smooth) => {

plum-std/Game.plum CHANGED Viewed

@@ -31,6 +31,18 @@ extern fun textureWidth(t: Int) -> Int
 extern fun textureHeight(t: Int) -> Int
 # Linear (true) or nearest (false, the default) filtering.
 extern fun textureSetSmooth(t: Int, smooth: Bool)
+# A blank, transparent texture of w x h pixels that can be drawn into with
+# `renderTarget`; -1 if a side is below 1 or above 8192.
+extern fun textureCreate(w: Int, h: Int) -> Int
+# Sends the following draws (and `clear`) into texture `t` made by `textureCreate`,
+# or back to the screen with -1; any other handle is ignored. Each target has its
+# own camera: selecting a target resets its camera to its pixels, and returning to
+# the screen restores the screen's camera. The texture's contents persist between
+# frames; draw it like any texture once the screen is selected again.
+extern fun renderTarget(t: Int)
+# The blend mode of the following draws: a `Blend` constant (other values are
+# ignored). Every frame starts with `Blend.Normal`.
+extern fun blendMode(m: Int)
 # The texture at its natural size, top-left at (x, y).
 extern fun drawTexture(t: Int, x: Float, y: Float, tint: Color)
 # The source rect (sx, sy, sw, sh) in texture pixels drawn into the dest rect
@@ -111,6 +123,14 @@ primitive Key =
   LeftShift = 340
   LeftControl = 341
+# Blend modes for `blendMode`: alpha blending, additive (brightens), multiply
+# (darkens, white leaves the target unchanged) and screen (lightens).
+primitive Blend =
+  Normal = 0
+  Add = 1
+  Multiply = 2
+  Screen = 3
 # Mouse button numbers for `isMouseDown` / `isMousePressed`.
 primitive Mouse =
   Left = 0
@@ -123,3 +143,7 @@ test "key and mouse constants use GLFW numbering"
   assert Key.Num0 == 48
   assert Key.LeftControl == 341
   assert Mouse.Right == 1
+test "blend constants"
+  assert Blend.Normal == 0
+  assert Blend.Screen == 3