Build Rust render graph core

Keep hot render state in a generic shared SOA arena and use worker messages only for allocation, graph compilation, loadout changes, and render pacing. Compile external S-expression graphs into upfront WebGPU resources, transient aliases, and reusable render bundles.

Amp-Thread-ID: https://ampcode.com/threads/T-01a01380-b478-77d0-84a0-102880a5c5ae
Co-authored-by: Heaust Azure <heaust.azure@gmail.com>

core/Cargo.toml

@@ -6,7 +6,14 @@ edition = "2021"
 
 [lib]
 crate-type = ["cdylib"]
+path = "lib.rs"
 
 [dependencies]
+gloo-timers = { version = "0.3", features = ["futures"] }
+js-sys = "0.3"
+serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+web-sys = { version = "0.3", features = ["OffscreenCanvas"] }
+wgpu = { version = "26", default-features = false, features = ["serde", "webgpu", "wgsl"] }

core/index.js

@@ -1,9 +1,17 @@
-const types = { f32: Float32Array, u32: Uint32Array, i32: Int32Array };
+const views = Object.freeze({ f32: Float32Array, u32: Uint32Array, i32: Int32Array });
 
 export class SharedRows {
   constructor(buffer, descriptor) {
+    if (!(buffer instanceof SharedArrayBuffer)) throw new TypeError("ROWS_DESCRIPTOR");
     this.buffer = buffer;
+    this.update(descriptor);
+  }
+
+  update(descriptor) {
+    if (!views[descriptor.format] || descriptor.name !== (this.descriptor?.name ?? descriptor.name))
+      throw new TypeError("ROWS_DESCRIPTOR");
     this.descriptor = Object.freeze(descriptor);
+    return this;
   }
 
   get name() { return this.descriptor.name; }
@@ -11,16 +19,18 @@ export class SharedRows {
   get stride() { return this.descriptor.stride; }
   get format() { return this.descriptor.format; }
   get view() {
-    return new types[this.format](this.buffer, this.descriptor.offset, this.rows * this.stride / 4);
+    const View = views[this.format];
+    return new View(this.buffer, this.descriptor.offset, this.descriptor.bytes / View.BYTES_PER_ELEMENT);
   }
 
   row(index) {
     if (!Number.isInteger(index) || index < 0 || index >= this.rows) throw new RangeError("ROW_RANGE");
-    const width = this.stride / 4;
+    const width = this.stride / views[this.format].BYTES_PER_ELEMENT;
     return this.view.subarray(index * width, (index + 1) * width);
   }
 
   read(index) { return Array.from(this.row(index)); }
+
   write(index, values) {
     const row = this.row(index);
     if (!values || values.length !== row.length) throw new RangeError("ROW_WIDTH");
@@ -49,30 +59,74 @@ export class YawnCore {
     this.#worker.addEventListener("messageerror", () => this.#fail("WORKER_ERROR"));
     this.#worker.start?.();
     const offscreen = canvas.transferControlToOffscreen?.() ?? canvas;
-    this.ready = this.#request("init", { canvas: offscreen, arenaBytes }, [offscreen])
-      .then(({ buffer }) => { this.#buffer = buffer; });
+    this.ready = this.#request("init", { canvas: offscreen, arenaBytes }, [offscreen]).then(result => {
+      this.#buffer = result.buffer;
+      for (const descriptor of result.rows) this.#arrays.set(
+        descriptor.name,
+        new SharedRows(this.#buffer, descriptor),
+      );
+    });
   }
 
-  async allocateRows({ name, rows, stride, format }) {
+  async createRows({ name, rows, stride, format }) {
     await this.ready;
-    const descriptor = await this.#request("allocate", { name, rows, stride, format });
-    const array = new SharedRows(this.#buffer, descriptor);
+    const descriptor = await this.#request("create-rows", { name, rows, stride, format });
+    const array = this.#arrays.get(name)?.update(descriptor)
+      ?? new SharedRows(this.#buffer, descriptor);
     this.#arrays.set(name, array);
     return array;
   }
 
+  async deleteRows(name) {
+    await this.ready;
+    await this.#request("delete-rows", { name });
+    this.#arrays.delete(name);
+  }
+
+  async allocateObject(name) {
+    await this.ready;
+    const { id, rows } = await this.#request("allocate-object", { name });
+    this.#arrays.get(name).update(rows);
+    return id;
+  }
+
+  async deleteObject(name, id) {
+    await this.ready;
+    return this.#request("delete-object", { name, id });
+  }
+
+  async compileGraph(serialized) {
+    await this.ready;
+    return this.#request("compile-graph", { serialized });
+  }
+
+  async switchLoadout(id) {
+    await this.ready;
+    return this.#request("switch-loadout", { id });
+  }
+
+  async play() {
+    await this.ready;
+    return this.#request("play");
+  }
+
+  async pause() {
+    await this.ready;
+    return this.#request("pause");
+  }
+
+  async setFps(fps) {
+    await this.ready;
+    return this.#request("set-fps", { fps });
+  }
+
   array(name) {
     const array = this.#arrays.get(name);
     if (!array) throw new Error(`UNKNOWN_ARRAY: ${name}`);
     return array;
   }
 
-  async loadGraph(serialized) {
-    await this.ready;
-    return this.#request("load-graph", { serialized });
-  }
-
-  #request(type, payload, transfer = []) {
+  #request(type, payload = {}, transfer = []) {
     const request = this.#next++;
     return new Promise((resolve, reject) => {
       this.#pending.set(request, { resolve, reject });

core/lib.rs

@@ -0,0 +1,149 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use wasm_bindgen::prelude::*;
+
+#[path = "render_graph/compiler.rs"]
+mod compiler;
+#[path = "renderer/wgpu.rs"]
+mod gpu;
+#[path = "render_graph/gpu_resource.rs"]
+mod gpu_resource;
+#[path = "render_graph/render_graph.rs"]
+mod graph;
+#[path = "renderer/render.rs"]
+mod render;
+mod render_data;
+#[path = "render_graph/store.rs"]
+mod store;
+
+use gpu::Wgpu;
+use render::RenderLoop;
+use render_data::RenderData;
+use store::Store;
+
+#[wasm_bindgen]
+pub struct Core {
+    data: Rc<RefCell<RenderData>>,
+    gpu: Rc<RefCell<Option<Wgpu>>>,
+    store: Rc<RefCell<Store>>,
+    render: Rc<RenderLoop>,
+}
+
+#[wasm_bindgen]
+impl Core {
+    #[wasm_bindgen(constructor)]
+    pub fn new(arena_bytes: u32) -> Result<Self, JsError> {
+        Ok(Self {
+            data: Rc::new(RefCell::new(
+                RenderData::new(arena_bytes).map_err(JsError::new)?,
+            )),
+            gpu: Rc::new(RefCell::new(None)),
+            store: Rc::new(RefCell::new(Store::default())),
+            render: Rc::new(RenderLoop::new()),
+        })
+    }
+
+    pub async fn initialize(&self, canvas: web_sys::OffscreenCanvas) -> Result<(), JsError> {
+        let gpu = Wgpu::new(canvas)
+            .await
+            .map_err(|error| JsError::new(&error))?;
+        *self.gpu.borrow_mut() = Some(gpu);
+        self.render
+            .start(self.gpu.clone(), self.store.clone(), self.data.clone());
+        Ok(())
+    }
+
+    pub fn rows(&self) -> String {
+        serde_json::to_string(&self.data.borrow().descriptors()).unwrap()
+    }
+
+    pub fn create_rows(
+        &self,
+        name: String,
+        rows: u32,
+        stride: u32,
+        format: String,
+    ) -> Result<String, JsError> {
+        let rows = self
+            .data
+            .borrow_mut()
+            .create_rows(name, rows, stride, format)
+            .map_err(JsError::new)?;
+        if let Some(gpu) = self.gpu.borrow().as_ref() {
+            self.store
+                .borrow_mut()
+                .refresh_rows(&rows.name, gpu, &self.data.borrow())
+                .map_err(|error| JsError::new(&error))?;
+        }
+        Ok(serde_json::to_string(&rows).unwrap())
+    }
+
+    pub fn delete_rows(&self, name: String) -> Result<(), JsError> {
+        if self.store.borrow().uses_rows(&name) {
+            return Err(JsError::new("ROWS_ACTIVE"));
+        }
+        self.data
+            .borrow_mut()
+            .delete_rows(&name)
+            .map_err(JsError::new)
+    }
+
+    pub fn allocate_object(&self, name: &str) -> Result<String, JsError> {
+        let (id, grew) = self
+            .data
+            .borrow_mut()
+            .allocate_object(name)
+            .map_err(JsError::new)?;
+        let rows = self
+            .data
+            .borrow()
+            .rows(name)
+            .ok_or_else(|| JsError::new("ROWS_UNKNOWN"))?
+            .clone();
+        if grew {
+            if let Some(gpu) = self.gpu.borrow().as_ref() {
+                self.store
+                    .borrow_mut()
+                    .refresh_rows(name, gpu, &self.data.borrow())
+                    .map_err(|error| JsError::new(&error))?;
+            }
+        }
+        Ok(serde_json::json!({ "id": id, "rows": rows }).to_string())
+    }
+
+    pub fn delete_object(&self, name: &str, id: u32) -> Result<(), JsError> {
+        self.data
+            .borrow_mut()
+            .delete_object(name, id)
+            .map_err(JsError::new)
+    }
+
+    pub fn compile_graph(&self, source: &str) -> Result<String, JsError> {
+        let graph = compiler::compile(source).map_err(JsError::new)?;
+        Ok(self.store.borrow_mut().save(graph))
+    }
+
+    pub fn switch_loadout(&self, id: &str) -> Result<(), JsError> {
+        let gpu = self.gpu.borrow();
+        let gpu = gpu
+            .as_ref()
+            .ok_or_else(|| JsError::new("WEBGPU_UNINITIALIZED"))?;
+        self.store
+            .borrow_mut()
+            .switch(id, gpu, &self.data.borrow())
+            .map_err(|error| JsError::new(&error))
+    }
+
+    pub fn play(&self) {
+        self.render.play();
+    }
+
+    pub fn pause(&self) {
+        self.render.pause();
+    }
+
+    pub fn set_fps(&self, fps: u32) -> Result<(), JsError> {
+        self.render.set_fps(fps).map_err(JsError::new)
+    }
+}

core/package.json

@@ -3,6 +3,6 @@
   "version": "0.1.0",
   "description": "Rust/WASM render data and render graph core",
   "type": "module",
-  "exports": "./src/index.js",
-  "files": ["src", "pkg"]
+  "exports": "./index.js",
+  "files": ["index.js", "worker.js", "pkg"]
 }

core/render_data.rs

@@ -0,0 +1,265 @@
+use std::collections::{BTreeMap, HashMap, HashSet};
+
+use serde::Serialize;
+
+const ALIGNMENT: u32 = 64;
+
+#[derive(Clone, Serialize)]
+pub struct Rows {
+    pub name: String,
+    pub rows: u32,
+    pub stride: u32,
+    pub format: String,
+    pub offset: u32,
+    pub bytes: u32,
+}
+
+#[derive(Default)]
+struct Slots {
+    active: HashSet<u32>,
+    free: Vec<u32>,
+    next: u32,
+}
+
+pub struct RenderData {
+    arena: Box<[u8]>,
+    arena_start: usize,
+    base: u32,
+    free: BTreeMap<u32, u32>,
+    rows: HashMap<String, Rows>,
+    slots: HashMap<String, Slots>,
+}
+
+impl RenderData {
+    pub fn new(capacity: u32) -> Result<Self, &'static str> {
+        if capacity < ALIGNMENT || capacity > u32::MAX - (ALIGNMENT - 1) {
+            return Err("INIT");
+        }
+        let mut arena = vec![0; (capacity + ALIGNMENT - 1) as usize].into_boxed_slice();
+        let pointer = arena.as_mut_ptr() as usize;
+        let aligned = (pointer + ALIGNMENT as usize - 1) & !(ALIGNMENT as usize - 1);
+        let mut data = Self {
+            arena,
+            arena_start: aligned - pointer,
+            base: aligned as u32,
+            free: BTreeMap::from([(0, capacity)]),
+            rows: HashMap::new(),
+            slots: HashMap::new(),
+        };
+        data.create_rows("info".into(), 1, 32, "f32".into())?;
+        Ok(data)
+    }
+
+    pub fn create_rows(
+        &mut self,
+        name: String,
+        rows: u32,
+        stride: u32,
+        format: String,
+    ) -> Result<Rows, &'static str> {
+        if name.is_empty()
+            || rows == 0
+            || stride < 16
+            || stride % 16 != 0
+            || !matches!(format.as_str(), "f32" | "u32" | "i32")
+        {
+            return Err("ROWS");
+        }
+        if let Some(current) = self.rows.get(&name).cloned() {
+            if current.stride != stride || current.format != format {
+                return Err("ROWS");
+            }
+            if rows <= current.rows {
+                return Ok(current);
+            }
+            if name == "info" {
+                return Err("ROWS_BUILTIN");
+            }
+            return self.grow_rows(current, rows);
+        }
+        let bytes = rows.checked_mul(stride).ok_or("ARENA_OOM")?;
+        let offset = self.reserve(bytes)?;
+        let end = offset + bytes;
+        self.arena[self.arena_start + offset as usize..self.arena_start + end as usize].fill(0);
+        let descriptor = Rows {
+            name: name.clone(),
+            rows,
+            stride,
+            format,
+            offset: self.base + offset,
+            bytes,
+        };
+        self.rows.insert(name, descriptor.clone());
+        self.slots.insert(descriptor.name.clone(), Slots::default());
+        Ok(descriptor)
+    }
+
+    pub fn delete_rows(&mut self, name: &str) -> Result<(), &'static str> {
+        if name == "info" {
+            return Err("ROWS_BUILTIN");
+        }
+        if self
+            .slots
+            .get(name)
+            .is_some_and(|slots| !slots.active.is_empty())
+        {
+            return Err("ROWS_ACTIVE");
+        }
+        let rows = self.rows.remove(name).ok_or("ROWS_UNKNOWN")?;
+        self.slots.remove(name);
+        self.release(rows.offset - self.base, rows.bytes);
+        Ok(())
+    }
+
+    pub fn rows(&self, name: &str) -> Option<&Rows> {
+        self.rows.get(name)
+    }
+
+    pub fn descriptors(&self) -> Vec<Rows> {
+        let mut rows = self.rows.values().cloned().collect::<Vec<_>>();
+        rows.sort_by_key(|rows| rows.offset);
+        rows
+    }
+
+    pub fn bytes(&self, name: &str) -> Option<&[u8]> {
+        let rows = self.rows(name)?;
+        let start = self.arena_start + (rows.offset - self.base) as usize;
+        Some(&self.arena[start..start + rows.bytes as usize])
+    }
+
+    pub fn allocate_object(&mut self, name: &str) -> Result<(u32, bool), &'static str> {
+        if name == "info" {
+            return Err("ROWS_BUILTIN");
+        }
+        let slots = self.slots.get(name).ok_or("ROWS_UNKNOWN")?;
+        let reused = slots.free.last().copied();
+        let id = reused.unwrap_or(slots.next);
+        let next = id.checked_add(1).ok_or("OBJECT_LIMIT")?;
+        let capacity = self.rows[name].rows;
+        let grew = id >= capacity;
+        if grew {
+            let descriptor = self.rows[name].clone();
+            self.grow_rows(descriptor, next)?;
+        }
+        let slots = self.slots.get_mut(name).unwrap();
+        if reused.is_some() {
+            slots.free.pop();
+        } else {
+            slots.next = next;
+        }
+        slots.active.insert(id);
+        Ok((id, grew))
+    }
+
+    pub fn delete_object(&mut self, name: &str, id: u32) -> Result<(), &'static str> {
+        let slots = self.slots.get_mut(name).ok_or("ROWS_UNKNOWN")?;
+        if !slots.active.remove(&id) {
+            return Err("OBJECT_UNKNOWN");
+        }
+        let rows = self.rows[name].clone();
+        let start = self.arena_start + (rows.offset - self.base + id * rows.stride) as usize;
+        self.arena[start..start + rows.stride as usize].fill(0);
+        slots.free.push(id);
+        Ok(())
+    }
+
+    fn grow_rows(&mut self, mut descriptor: Rows, rows: u32) -> Result<Rows, &'static str> {
+        let bytes = rows.checked_mul(descriptor.stride).ok_or("ARENA_OOM")?;
+        let old_offset = descriptor.offset - self.base;
+        let old_end = old_offset + descriptor.bytes;
+        let extra = bytes - descriptor.bytes;
+        if self
+            .free
+            .get(&old_end)
+            .is_some_and(|available| *available >= extra)
+        {
+            let available = self.free.remove(&old_end).unwrap();
+            if available > extra {
+                self.free.insert(old_end + extra, available - extra);
+            }
+            self.arena[self.arena_start + old_end as usize
+                ..self.arena_start + (old_end + extra) as usize]
+                .fill(0);
+        } else {
+            let offset = self.reserve(bytes)?;
+            let start = self.arena_start + offset as usize;
+            self.arena[start..start + bytes as usize].fill(0);
+            self.arena.copy_within(
+                self.arena_start + old_offset as usize..self.arena_start + old_end as usize,
+                start,
+            );
+            self.release(old_offset, descriptor.bytes);
+            descriptor.offset = self.base + offset;
+        }
+        descriptor.rows = rows;
+        descriptor.bytes = bytes;
+        self.rows
+            .insert(descriptor.name.clone(), descriptor.clone());
+        Ok(descriptor)
+    }
+
+    pub fn update_info(&mut self, delta: f32, frame: u32, elapsed: f32, fps: u32) {
+        let start = self.arena_start + (self.rows["info"].offset - self.base) as usize;
+        for (index, value) in [delta, frame as f32, elapsed, fps as f32]
+            .iter()
+            .enumerate()
+        {
+            self.arena[start + index * 4..start + index * 4 + 4]
+                .copy_from_slice(&value.to_le_bytes());
+        }
+    }
+
+    pub fn skip_render(&self) -> bool {
+        let rows = &self.rows["info"];
+        let start = self.arena_start + (rows.offset - self.base) as usize + 16;
+        f32::from_le_bytes(self.arena[start..start + 4].try_into().unwrap()) == 1.0
+    }
+
+    fn reserve(&mut self, bytes: u32) -> Result<u32, &'static str> {
+        let (block, block_bytes, offset) = self
+            .free
+            .iter()
+            .find_map(|(&block, &block_bytes)| {
+                let offset = align(block)?;
+                (offset.checked_add(bytes)? <= block.checked_add(block_bytes)?).then_some((
+                    block,
+                    block_bytes,
+                    offset,
+                ))
+            })
+            .ok_or("ARENA_OOM")?;
+        self.free.remove(&block);
+        if offset > block {
+            self.free.insert(block, offset - block);
+        }
+        let end = offset + bytes;
+        let block_end = block + block_bytes;
+        if end < block_end {
+            self.free.insert(end, block_end - end);
+        }
+        Ok(offset)
+    }
+
+    fn release(&mut self, mut offset: u32, mut bytes: u32) {
+        if let Some((&previous, &previous_bytes)) = self.free.range(..offset).next_back() {
+            if previous + previous_bytes == offset {
+                self.free.remove(&previous);
+                offset = previous;
+                bytes += previous_bytes;
+            }
+        }
+        if let Some((&next, &next_bytes)) = self.free.range(offset..).next() {
+            if offset + bytes == next {
+                self.free.remove(&next);
+                bytes += next_bytes;
+            }
+        }
+        self.free.insert(offset, bytes);
+    }
+}
+
+fn align(value: u32) -> Option<u32> {
+    value
+        .checked_add(ALIGNMENT - 1)
+        .map(|value| value & !(ALIGNMENT - 1))
+}

core/render_graph/compiler.rs

@@ -0,0 +1,162 @@
+use serde_json::{Map, Value};
+
+use crate::graph::RenderGraph;
+
+pub fn compile(source: &str) -> Result<RenderGraph, &'static str> {
+    let Expression::List(mut root) = Parser::parse(source)? else {
+        return Err("GRAPH_WIRE");
+    };
+    if root.len() != 3
+        || !matches!(&root[0], Expression::Atom(Value::String(tag)) if tag == "yawn-graph")
+        || !matches!(&root[1], Expression::Atom(Value::Number(version)) if version.as_u64() == Some(1))
+    {
+        return Err("GRAPH_WIRE");
+    }
+    let value = decode(root.pop().unwrap())?;
+    let mut graph: RenderGraph = serde_json::from_value(value).map_err(|_| "GRAPH_SHAPE")?;
+    graph.prepare()?;
+    Ok(graph)
+}
+
+enum Expression {
+    Atom(Value),
+    List(Vec<Expression>),
+}
+
+struct Parser<'a> {
+    source: &'a [u8],
+    at: usize,
+}
+
+impl<'a> Parser<'a> {
+    fn parse(source: &'a str) -> Result<Expression, &'static str> {
+        let mut parser = Self {
+            source: source.as_bytes(),
+            at: 0,
+        };
+        let expression = parser.expression()?;
+        parser.whitespace();
+        (parser.at == parser.source.len())
+            .then_some(expression)
+            .ok_or("GRAPH_WIRE")
+    }
+
+    fn expression(&mut self) -> Result<Expression, &'static str> {
+        self.whitespace();
+        match self.source.get(self.at) {
+            Some(b'(') => self.list(),
+            Some(b'"') => self.string(),
+            Some(b')') | None => Err("GRAPH_WIRE"),
+            Some(_) => self.atom(),
+        }
+    }
+
+    fn list(&mut self) -> Result<Expression, &'static str> {
+        self.at += 1;
+        let mut values = Vec::new();
+        loop {
+            self.whitespace();
+            match self.source.get(self.at) {
+                Some(b')') => {
+                    self.at += 1;
+                    return Ok(Expression::List(values));
+                }
+                None => return Err("GRAPH_WIRE"),
+                _ => values.push(self.expression()?),
+            }
+        }
+    }
+
+    fn string(&mut self) -> Result<Expression, &'static str> {
+        let start = self.at;
+        self.at += 1;
+        let mut escaped = false;
+        while let Some(&byte) = self.source.get(self.at) {
+            self.at += 1;
+            if escaped {
+                escaped = false;
+            } else if byte == b'\\' {
+                escaped = true;
+            } else if byte == b'"' {
+                let value = serde_json::from_slice(&self.source[start..self.at])
+                    .map_err(|_| "GRAPH_WIRE")?;
+                return Ok(Expression::Atom(Value::String(value)));
+            }
+        }
+        Err("GRAPH_WIRE")
+    }
+
+    fn atom(&mut self) -> Result<Expression, &'static str> {
+        let start = self.at;
+        while self
+            .source
+            .get(self.at)
+            .is_some_and(|byte| !byte.is_ascii_whitespace() && !matches!(byte, b'(' | b')'))
+        {
+            self.at += 1;
+        }
+        let token = std::str::from_utf8(&self.source[start..self.at]).map_err(|_| "GRAPH_WIRE")?;
+        let value = match token {
+            "true" => Value::Bool(true),
+            "false" => Value::Bool(false),
+            "null" => Value::Null,
+            _ => serde_json::from_str::<Value>(token)
+                .ok()
+                .filter(Value::is_number)
+                .unwrap_or_else(|| Value::String(token.into())),
+        };
+        Ok(Expression::Atom(value))
+    }
+
+    fn whitespace(&mut self) {
+        while self
+            .source
+            .get(self.at)
+            .is_some_and(u8::is_ascii_whitespace)
+        {
+            self.at += 1;
+        }
+    }
+}
+
+fn decode(expression: Expression) -> Result<Value, &'static str> {
+    let Expression::List(mut values) = expression else {
+        return match expression {
+            Expression::Atom(value) => Ok(value),
+            Expression::List(_) => unreachable!(),
+        };
+    };
+    if values.is_empty() {
+        return Err("GRAPH_WIRE");
+    }
+    let tag = match values.remove(0) {
+        Expression::Atom(Value::String(tag)) => tag,
+        _ => return Err("GRAPH_WIRE"),
+    };
+    if tag == "array" {
+        return values.into_iter().map(decode).collect();
+    }
+    if tag != "object" {
+        return Err("GRAPH_WIRE");
+    }
+    let mut object = Map::new();
+    for field in values {
+        let Expression::List(mut field) = field else {
+            return Err("GRAPH_WIRE");
+        };
+        if field.len() != 3
+            || !matches!(&field[0], Expression::Atom(Value::String(tag)) if tag == "field")
+        {
+            return Err("GRAPH_WIRE");
+        }
+        let value = decode(field.pop().unwrap())?;
+        let key = match field.pop().unwrap() {
+            Expression::Atom(Value::String(key)) => key,
+            _ => return Err("GRAPH_WIRE"),
+        };
+        if object.insert(key, value).is_some() {
+            return Err("GRAPH_WIRE");
+        }
+    }
+    Ok(Value::Object(object))
+}

core/render_graph/gpu_resource.rs

@@ -0,0 +1,545 @@
+use std::collections::{BTreeMap, HashMap};
+use std::num::NonZeroU64;
+
+use serde::de::DeserializeOwned;
+use serde_json::Value;
+
+use crate::gpu::Wgpu;
+use crate::graph::{Binding, Extent, Pass, RenderGraph, RenderPipeline, Texture};
+use crate::render_data::RenderData;
+
+pub struct GpuResources {
+    pub buffers: HashMap<String, GpuBuffer>,
+    pub textures: Vec<GpuTexture>,
+    pub texture_slots: HashMap<String, usize>,
+    pub samplers: HashMap<String, wgpu::Sampler>,
+    pub render_pipelines: HashMap<String, wgpu::RenderPipeline>,
+    pub compute_pipelines: HashMap<String, wgpu::ComputePipeline>,
+    pub passes: Vec<GpuPass>,
+}
+
+pub struct GpuBuffer {
+    pub buffer: wgpu::Buffer,
+    pub source: String,
+}
+
+pub struct GpuTexture {
+    pub _texture: wgpu::Texture,
+    pub view: wgpu::TextureView,
+}
+
+pub enum GpuPass {
+    Render(wgpu::RenderBundle),
+    Compute {
+        pipeline: wgpu::ComputePipeline,
+        bind_groups: Vec<(u32, wgpu::BindGroup)>,
+    },
+}
+
+impl GpuResources {
+    pub fn activate(graph: &RenderGraph, gpu: &Wgpu, data: &RenderData) -> Result<Self, String> {
+        let mut buffers = HashMap::new();
+        for source in &graph.resources.buffers {
+            let rows = data.rows(&source.array).ok_or("GRAPH_ARRAY_UNKNOWN")?;
+            let buffer = gpu.device.create_buffer(&wgpu::BufferDescriptor {
+                label: Some(&source.id),
+                size: u64::from(rows.bytes.max(4)),
+                usage: buffer_usage(&source.usage)?,
+                mapped_at_creation: false,
+            });
+            gpu.queue
+                .write_buffer(&buffer, 0, data.bytes(&source.array).unwrap());
+            buffers.insert(
+                source.id.clone(),
+                GpuBuffer {
+                    buffer,
+                    source: source.array.clone(),
+                },
+            );
+        }
+
+        let mut textures = Vec::new();
+        let mut physical_slots = HashMap::new();
+        let mut texture_slots = HashMap::new();
+        for source in &graph.resources.textures {
+            let physical = match physical_slots.get(&source.slot) {
+                Some(&physical) => physical,
+                None => {
+                    let descriptor = texture_descriptor(source, gpu.width, gpu.height)?;
+                    let texture = gpu.device.create_texture(&descriptor);
+                    let physical = textures.len();
+                    textures.push(GpuTexture {
+                        view: texture.create_view(&wgpu::TextureViewDescriptor::default()),
+                        _texture: texture,
+                    });
+                    physical_slots.insert(source.slot, physical);
+                    physical
+                }
+            };
+            texture_slots.insert(source.id.clone(), physical);
+        }
+
+        let mut samplers = HashMap::new();
+        for source in &graph.resources.samplers {
+            samplers.insert(
+                source.id.clone(),
+                gpu.device
+                    .create_sampler(&sampler_descriptor(&source.id, &source.descriptor)?),
+            );
+        }
+
+        let render_pipelines = graph
+            .pipelines
+            .render
+            .iter()
+            .map(|source| {
+                create_render_pipeline(source, gpu).map(|pipeline| (source.id.clone(), pipeline))
+            })
+            .collect::<Result<HashMap<_, _>, _>>()?;
+        let compute_pipelines = graph
+            .pipelines
+            .compute
+            .iter()
+            .map(|source| {
+                let module = gpu
+                    .device
+                    .create_shader_module(wgpu::ShaderModuleDescriptor {
+                        label: Some(&source.id),
+                        source: wgpu::ShaderSource::Wgsl(source.code.clone().into()),
+                    });
+                let pipeline =
+                    gpu.device
+                        .create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
+                            label: Some(&source.id),
+                            layout: None,
+                            module: &module,
+                            entry_point: Some(&source.entry),
+                            compilation_options: Default::default(),
+                            cache: None,
+                        });
+                Ok::<_, String>((source.id.clone(), pipeline))
+            })
+            .collect::<Result<HashMap<_, _>, _>>()?;
+
+        let mut resources = Self {
+            buffers,
+            textures,
+            texture_slots,
+            samplers,
+            render_pipelines,
+            compute_pipelines,
+            passes: Vec::new(),
+        };
+        for pass in &graph.passes {
+            let compiled = match pass.kind.as_str() {
+                "render" => GpuPass::Render(resources.render_bundle(graph, pass, gpu)?),
+                "compute" => {
+                    let pipeline = resources
+                        .compute_pipelines
+                        .get(&pass.pipeline)
+                        .ok_or("GRAPH_PIPELINE")?
+                        .clone();
+                    let bind_groups = resources.bind_groups(
+                        pass,
+                        |group| pipeline.get_bind_group_layout(group),
+                        gpu,
+                    )?;
+                    GpuPass::Compute {
+                        pipeline,
+                        bind_groups,
+                    }
+                }
+                _ => return Err("GRAPH_PASS".into()),
+            };
+            resources.passes.push(compiled);
+        }
+        Ok(resources)
+    }
+
+    pub fn texture_view(&self, id: &str) -> Option<&wgpu::TextureView> {
+        self.texture_slots
+            .get(id)
+            .and_then(|slot| self.textures.get(*slot))
+            .map(|texture| &texture.view)
+    }
+
+    fn render_bundle(
+        &self,
+        graph: &RenderGraph,
+        pass: &Pass,
+        gpu: &Wgpu,
+    ) -> Result<wgpu::RenderBundle, String> {
+        let pipeline = self
+            .render_pipelines
+            .get(&pass.pipeline)
+            .ok_or("GRAPH_PIPELINE")?;
+        let declaration = graph
+            .pipelines
+            .render
+            .iter()
+            .find(|pipeline| pipeline.id == pass.pipeline)
+            .ok_or("GRAPH_PIPELINE")?;
+        let color_formats = pass
+            .color
+            .iter()
+            .map(|attachment| attachment_format(graph, &attachment.resource, gpu.format).map(Some))
+            .collect::<Result<Vec<_>, _>>()?;
+        let depth_stencil = pass
+            .depth
+            .as_ref()
+            .map(|attachment| {
+                Ok::<_, String>(wgpu::RenderBundleDepthStencil {
+                    format: attachment_format(graph, &attachment.resource, gpu.format)?,
+                    depth_read_only: false,
+                    stencil_read_only: true,
+                })
+            })
+            .transpose()?;
+        let mut encoder =
+            gpu.device
+                .create_render_bundle_encoder(&wgpu::RenderBundleEncoderDescriptor {
+                    label: Some(&pass.id),
+                    color_formats: &color_formats,
+                    depth_stencil,
+                    sample_count: multisample(&declaration.multisample)?.count,
+                    multiview: None,
+                });
+        encoder.set_pipeline(pipeline);
+        for (group, bind_group) in
+            self.bind_groups(pass, |group| pipeline.get_bind_group_layout(group), gpu)?
+        {
+            encoder.set_bind_group(group, &bind_group, &[]);
+        }
+        for binding in &pass.vertex_buffers {
+            let buffer = &self
+                .buffers
+                .get(&binding.resource)
+                .ok_or("GRAPH_RESOURCE_UNKNOWN")?
+                .buffer;
+            encoder.set_vertex_buffer(binding.slot, buffer.slice(binding.offset..));
+        }
+        if let Some(binding) = &pass.index_buffer {
+            let buffer = &self
+                .buffers
+                .get(&binding.resource)
+                .ok_or("GRAPH_RESOURCE_UNKNOWN")?
+                .buffer;
+            encoder.set_index_buffer(
+                buffer.slice(binding.offset..),
+                parse(&binding.format, "GRAPH_INDEX_FORMAT")?,
+            );
+            encoder.draw_indexed(
+                pass.draw.first_index..pass.draw.first_index + pass.draw.indices,
+                pass.draw.base_vertex,
+                pass.draw.first_instance..pass.draw.first_instance + pass.draw.instances,
+            );
+        } else {
+            encoder.draw(
+                pass.draw.first_vertex..pass.draw.first_vertex + pass.draw.vertices,
+                pass.draw.first_instance..pass.draw.first_instance + pass.draw.instances,
+            );
+        }
+        Ok(encoder.finish(&wgpu::RenderBundleDescriptor {
+            label: Some(&pass.id),
+        }))
+    }
+
+    fn bind_groups(
+        &self,
+        pass: &Pass,
+        layout: impl Fn(u32) -> wgpu::BindGroupLayout,
+        gpu: &Wgpu,
+    ) -> Result<Vec<(u32, wgpu::BindGroup)>, String> {
+        let mut groups: BTreeMap<u32, Vec<&Binding>> = BTreeMap::new();
+        for binding in &pass.bindings {
+            groups.entry(binding.group).or_default().push(binding);
+        }
+        groups
+            .into_iter()
+            .map(|(group, bindings)| {
+                let entries = bindings
+                    .into_iter()
+                    .map(|binding| {
+                        let resource = if let Some(buffer) = self.buffers.get(&binding.resource) {
+                            wgpu::BindingResource::Buffer(wgpu::BufferBinding {
+                                buffer: &buffer.buffer,
+                                offset: binding.offset,
+                                size: binding.size.and_then(NonZeroU64::new),
+                            })
+                        } else if let Some(view) = self.texture_view(&binding.resource) {
+                            wgpu::BindingResource::TextureView(view)
+                        } else if let Some(sampler) = self.samplers.get(&binding.resource) {
+                            wgpu::BindingResource::Sampler(sampler)
+                        } else {
+                            return Err("GRAPH_RESOURCE_UNKNOWN".into());
+                        };
+                        Ok(wgpu::BindGroupEntry {
+                            binding: binding.binding,
+                            resource,
+                        })
+                    })
+                    .collect::<Result<Vec<_>, String>>()?;
+                let bind_group = gpu.device.create_bind_group(&wgpu::BindGroupDescriptor {
+                    label: Some(&pass.id),
+                    layout: &layout(group),
+                    entries: &entries,
+                });
+                Ok((group, bind_group))
+            })
+            .collect()
+    }
+}
+
+fn create_render_pipeline(
+    source: &RenderPipeline,
+    gpu: &Wgpu,
+) -> Result<wgpu::RenderPipeline, String> {
+    let module = gpu
+        .device
+        .create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some(&source.id),
+            source: wgpu::ShaderSource::Wgsl(source.code.clone().into()),
+        });
+    let attributes = source
+        .vertex
+        .buffers
+        .iter()
+        .map(|buffer| {
+            buffer
+                .attributes
+                .iter()
+                .map(|attribute| {
+                    Ok(wgpu::VertexAttribute {
+                        format: parse(&attribute.format, "GRAPH_VERTEX_FORMAT")?,
+                        offset: attribute.offset,
+                        shader_location: attribute.shader_location,
+                    })
+                })
+                .collect::<Result<Vec<_>, String>>()
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+    let layouts = source
+        .vertex
+        .buffers
+        .iter()
+        .zip(&attributes)
+        .map(|(buffer, attributes)| {
+            Ok(wgpu::VertexBufferLayout {
+                array_stride: buffer.array_stride,
+                step_mode: parse(&buffer.step_mode, "GRAPH_VERTEX_STEP")?,
+                attributes,
+            })
+        })
+        .collect::<Result<Vec<_>, String>>()?;
+    let targets = source
+        .fragment
+        .targets
+        .iter()
+        .map(|target| {
+            let format = if target.format == "canvas" {
+                gpu.format
+            } else {
+                parse(&target.format, "GRAPH_TEXTURE_FORMAT")?
+            };
+            let blend = (!target.blend.is_null())
+                .then(|| {
+                    serde_json::from_value::<wgpu::BlendState>(target.blend.clone())
+                        .map_err(|_| String::from("GRAPH_BLEND"))
+                })
+                .transpose()?;
+            let write_mask = match target.write_mask {
+                Some(bits) => wgpu::ColorWrites::from_bits(bits).ok_or("GRAPH_WRITE_MASK")?,
+                None => wgpu::ColorWrites::ALL,
+            };
+            Ok(Some(wgpu::ColorTargetState {
+                format,
+                blend,
+                write_mask,
+            }))
+        })
+        .collect::<Result<Vec<_>, String>>()?;
+    Ok(gpu
+        .device
+        .create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some(&source.id),
+            layout: None,
+            vertex: wgpu::VertexState {
+                module: &module,
+                entry_point: Some(&source.vertex.entry),
+                compilation_options: Default::default(),
+                buffers: &layouts,
+            },
+            primitive: primitive(&source.primitive)?,
+            depth_stencil: depth_stencil(&source.depth_stencil)?,
+            multisample: multisample(&source.multisample)?,
+            fragment: Some(wgpu::FragmentState {
+                module: &module,
+                entry_point: Some(&source.fragment.entry),
+                compilation_options: Default::default(),
+                targets: &targets,
+            }),
+            multiview: None,
+            cache: None,
+        }))
+}
+
+fn buffer_usage(names: &[String]) -> Result<wgpu::BufferUsages, String> {
+    names
+        .iter()
+        .try_fold(wgpu::BufferUsages::COPY_DST, |usage, name| {
+            Ok(usage
+                | match name.as_str() {
+                    "uniform" => wgpu::BufferUsages::UNIFORM,
+                    "storage" => wgpu::BufferUsages::STORAGE,
+                    "vertex" => wgpu::BufferUsages::VERTEX,
+                    "index" => wgpu::BufferUsages::INDEX,
+                    "indirect" => wgpu::BufferUsages::INDIRECT,
+                    "copySrc" => wgpu::BufferUsages::COPY_SRC,
+                    _ => return Err("GRAPH_BUFFER_USAGE".into()),
+                })
+        })
+}
+
+fn texture_usage(names: &[String]) -> Result<wgpu::TextureUsages, String> {
+    names
+        .iter()
+        .try_fold(wgpu::TextureUsages::empty(), |usage, name| {
+            Ok(usage
+                | match name.as_str() {
+                    "render" => wgpu::TextureUsages::RENDER_ATTACHMENT,
+                    "sampled" => wgpu::TextureUsages::TEXTURE_BINDING,
+                    "storage" => wgpu::TextureUsages::STORAGE_BINDING,
+                    "copySrc" => wgpu::TextureUsages::COPY_SRC,
+                    "copyDst" => wgpu::TextureUsages::COPY_DST,
+                    _ => return Err("GRAPH_TEXTURE_USAGE".into()),
+                })
+        })
+}
+
+fn texture_descriptor(
+    source: &Texture,
+    width: u32,
+    height: u32,
+) -> Result<wgpu::TextureDescriptor<'_>, String> {
+    let value = |index, canvas| -> Result<u32, String> {
+        match source.size.get(index) {
+            Some(Extent::Pixels(value)) => Ok(*value),
+            Some(Extent::Canvas(value)) if value == "canvas" => Ok(canvas),
+            Some(Extent::Canvas(_)) => Err("GRAPH_TEXTURE_SIZE".into()),
+            None => Ok(canvas),
+        }
+    };
+    Ok(wgpu::TextureDescriptor {
+        label: Some(&source.id),
+        size: wgpu::Extent3d {
+            width: value(0, width)?,
+            height: value(1, height)?,
+            depth_or_array_layers: value(2, 1)?,
+        },
+        mip_level_count: source.mip_level_count,
+        sample_count: source.sample_count,
+        dimension: parse(&source.dimension, "GRAPH_TEXTURE_DIMENSION")?,
+        format: parse(&source.format, "GRAPH_TEXTURE_FORMAT")?,
+        usage: texture_usage(&source.usage)?,
+        view_formats: &[],
+    })
+}
+
+fn attachment_format(
+    graph: &RenderGraph,
+    id: &str,
+    surface: wgpu::TextureFormat,
+) -> Result<wgpu::TextureFormat, String> {
+    if id == "canvas" {
+        return Ok(surface);
+    }
+    graph
+        .resources
+        .textures
+        .iter()
+        .find(|texture| texture.id == id)
+        .ok_or_else(|| "GRAPH_ATTACHMENT".into())
+        .and_then(|texture| parse(&texture.format, "GRAPH_TEXTURE_FORMAT"))
+}
+
+fn primitive(value: &Value) -> Result<wgpu::PrimitiveState, String> {
+    if value.is_null() {
+        return Ok(Default::default());
+    }
+    serde_json::from_value(value.clone()).map_err(|_| "GRAPH_PRIMITIVE".into())
+}
+
+fn depth_stencil(value: &Value) -> Result<Option<wgpu::DepthStencilState>, String> {
+    if value.is_null() {
+        return Ok(None);
+    }
+    serde_json::from_value(value.clone())
+        .map(Some)
+        .map_err(|_| "GRAPH_DEPTH_STENCIL".into())
+}
+
+fn multisample(value: &Value) -> Result<wgpu::MultisampleState, String> {
+    if value.is_null() {
+        return Ok(Default::default());
+    }
+    let object = value.as_object().ok_or("GRAPH_MULTISAMPLE")?;
+    Ok(wgpu::MultisampleState {
+        count: object.get("count").and_then(Value::as_u64).unwrap_or(1) as u32,
+        mask: object
+            .get("mask")
+            .and_then(Value::as_u64)
+            .unwrap_or(u64::MAX),
+        alpha_to_coverage_enabled: object
+            .get("alphaToCoverageEnabled")
+            .and_then(Value::as_bool)
+            .unwrap_or(false),
+    })
+}
+
+fn sampler_descriptor<'a>(
+    label: &'a str,
+    value: &Value,
+) -> Result<wgpu::SamplerDescriptor<'a>, String> {
+    let mut descriptor = wgpu::SamplerDescriptor {
+        label: Some(label),
+        ..Default::default()
+    };
+    let Some(object) = value.as_object() else {
+        return Ok(descriptor);
+    };
+    macro_rules! enum_field {
+        ($json:literal, $field:ident, $code:literal) => {
+            if let Some(value) = object.get($json).and_then(Value::as_str) {
+                descriptor.$field = parse(value, $code)?;
+            }
+        };
+    }
+    enum_field!("addressModeU", address_mode_u, "GRAPH_SAMPLER");
+    enum_field!("addressModeV", address_mode_v, "GRAPH_SAMPLER");
+    enum_field!("addressModeW", address_mode_w, "GRAPH_SAMPLER");
+    enum_field!("magFilter", mag_filter, "GRAPH_SAMPLER");
+    enum_field!("minFilter", min_filter, "GRAPH_SAMPLER");
+    enum_field!("mipmapFilter", mipmap_filter, "GRAPH_SAMPLER");
+    descriptor.lod_min_clamp = object
+        .get("lodMinClamp")
+        .and_then(Value::as_f64)
+        .unwrap_or(0.0) as f32;
+    descriptor.lod_max_clamp = object
+        .get("lodMaxClamp")
+        .and_then(Value::as_f64)
+        .unwrap_or(32.0) as f32;
+    descriptor.compare = object
+        .get("compare")
+        .and_then(Value::as_str)
+        .map(|value| parse(value, "GRAPH_SAMPLER"))
+        .transpose()?;
+    descriptor.anisotropy_clamp = object
+        .get("anisotropyClamp")
+        .and_then(Value::as_u64)
+        .unwrap_or(1) as u16;
+    Ok(descriptor)
+}
+
+fn parse<T: DeserializeOwned>(value: &str, code: &str) -> Result<T, String> {
+    serde_json::from_value(Value::String(value.into())).map_err(|_| code.into())
+}

core/render_graph/render_graph.rs

@@ -0,0 +1,500 @@
+use std::collections::{HashMap, HashSet};
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+#[derive(Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RenderGraph {
+    pub id: String,
+    #[serde(default)]
+    pub resources: ResourceDeclarations,
+    #[serde(default)]
+    pub pipelines: PipelineDeclarations,
+    pub passes: Vec<Pass>,
+}
+
+#[derive(Clone, Default, Deserialize)]
+pub struct ResourceDeclarations {
+    #[serde(default)]
+    pub buffers: Vec<Buffer>,
+    #[serde(default)]
+    pub textures: Vec<Texture>,
+    #[serde(default)]
+    pub samplers: Vec<Sampler>,
+}
+
+#[derive(Clone, Deserialize)]
+pub struct Buffer {
+    pub id: String,
+    pub array: String,
+    #[serde(default)]
+    pub usage: Vec<String>,
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Texture {
+    pub id: String,
+    #[serde(default)]
+    pub size: Vec<Extent>,
+    pub format: String,
+    #[serde(default)]
+    pub usage: Vec<String>,
+    #[serde(default = "one")]
+    pub mip_level_count: u32,
+    #[serde(default = "one")]
+    pub sample_count: u32,
+    #[serde(default = "dimension")]
+    pub dimension: String,
+    #[serde(default = "yes")]
+    pub transient: bool,
+    #[serde(skip)]
+    pub slot: usize,
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum Extent {
+    Pixels(u32),
+    Canvas(String),
+}
+
+#[derive(Clone, Deserialize)]
+pub struct Sampler {
+    pub id: String,
+    #[serde(default)]
+    pub descriptor: Value,
+}
+
+#[derive(Clone, Default, Deserialize)]
+pub struct PipelineDeclarations {
+    #[serde(default)]
+    pub render: Vec<RenderPipeline>,
+    #[serde(default)]
+    pub compute: Vec<ComputePipeline>,
+}
+
+#[derive(Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RenderPipeline {
+    pub id: String,
+    pub code: String,
+    #[serde(default)]
+    pub vertex: VertexStage,
+    #[serde(default)]
+    pub fragment: FragmentStage,
+    #[serde(default)]
+    pub primitive: Value,
+    #[serde(default)]
+    pub depth_stencil: Value,
+    #[serde(default)]
+    pub multisample: Value,
+}
+
+#[derive(Clone, Deserialize)]
+pub struct ComputePipeline {
+    pub id: String,
+    pub code: String,
+    #[serde(default = "compute_entry")]
+    pub entry: String,
+}
+
+#[derive(Clone, Deserialize)]
+pub struct VertexStage {
+    #[serde(default = "vertex_entry")]
+    pub entry: String,
+    #[serde(default)]
+    pub buffers: Vec<VertexBuffer>,
+}
+
+impl Default for VertexStage {
+    fn default() -> Self {
+        Self {
+            entry: vertex_entry(),
+            buffers: Vec::new(),
+        }
+    }
+}
+
+#[derive(Clone, Default, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VertexBuffer {
+    pub array_stride: u64,
+    #[serde(default = "vertex_step")]
+    pub step_mode: String,
+    #[serde(default)]
+    pub attributes: Vec<VertexAttribute>,
+}
+
+#[derive(Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VertexAttribute {
+    pub format: String,
+    pub offset: u64,
+    pub shader_location: u32,
+}
+
+#[derive(Clone, Deserialize)]
+pub struct FragmentStage {
+    #[serde(default = "fragment_entry")]
+    pub entry: String,
+    #[serde(default)]
+    pub targets: Vec<FragmentTarget>,
+}
+
+impl Default for FragmentStage {
+    fn default() -> Self {
+        Self {
+            entry: fragment_entry(),
+            targets: Vec::new(),
+        }
+    }
+}
+
+#[derive(Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FragmentTarget {
+    pub format: String,
+    #[serde(default)]
+    pub blend: Value,
+    pub write_mask: Option<u32>,
+}
+
+#[derive(Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Pass {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub kind: String,
+    pub pipeline: String,
+    #[serde(default)]
+    pub after: Vec<String>,
+    #[serde(skip)]
+    pub dependencies: Vec<usize>,
+    #[serde(default)]
+    pub bindings: Vec<Binding>,
+    #[serde(default)]
+    pub color: Vec<ColorAttachment>,
+    pub depth: Option<DepthAttachment>,
+    #[serde(default)]
+    pub vertex_buffers: Vec<VertexBinding>,
+    pub index_buffer: Option<IndexBinding>,
+    #[serde(default)]
+    pub draw: Draw,
+    #[serde(default = "dispatch")]
+    pub dispatch: [u32; 3],
+}
+
+#[derive(Clone, Deserialize)]
+pub struct Binding {
+    #[serde(default)]
+    pub group: u32,
+    pub binding: u32,
+    pub resource: String,
+    #[serde(default)]
+    pub offset: u64,
+    pub size: Option<u64>,
+}
+
+#[derive(Clone, Deserialize)]
+pub struct ColorAttachment {
+    pub resource: String,
+    #[serde(default)]
+    pub clear: Vec<f32>,
+    #[serde(default = "clear_op")]
+    pub load: String,
+    #[serde(default = "store_op")]
+    pub store: String,
+}
+
+#[derive(Clone, Deserialize)]
+pub struct DepthAttachment {
+    pub resource: String,
+    #[serde(default = "one_f32")]
+    pub clear: f32,
+    #[serde(default = "clear_op")]
+    pub load: String,
+    #[serde(default = "store_op")]
+    pub store: String,
+}
+
+#[derive(Clone, Deserialize)]
+pub struct VertexBinding {
+    #[serde(default)]
+    pub slot: u32,
+    pub resource: String,
+    #[serde(default)]
+    pub offset: u64,
+}
+
+#[derive(Clone, Deserialize)]
+pub struct IndexBinding {
+    pub resource: String,
+    #[serde(default = "index_format")]
+    pub format: String,
+    #[serde(default)]
+    pub offset: u64,
+}
+
+#[derive(Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Draw {
+    #[serde(default = "three")]
+    pub vertices: u32,
+    #[serde(default)]
+    pub indices: u32,
+    #[serde(default = "one")]
+    pub instances: u32,
+    #[serde(default)]
+    pub first_vertex: u32,
+    #[serde(default)]
+    pub first_index: u32,
+    #[serde(default)]
+    pub base_vertex: i32,
+    #[serde(default)]
+    pub first_instance: u32,
+}
+
+impl Default for Draw {
+    fn default() -> Self {
+        Self {
+            vertices: 3,
+            indices: 0,
+            instances: 1,
+            first_vertex: 0,
+            first_index: 0,
+            base_vertex: 0,
+            first_instance: 0,
+        }
+    }
+}
+
+impl RenderGraph {
+    pub fn prepare(&mut self) -> Result<(), &'static str> {
+        if self.id.is_empty() || self.passes.is_empty() {
+            return Err("GRAPH_SHAPE");
+        }
+        let mut ids = HashMap::new();
+        for (index, pass) in self.passes.iter().enumerate() {
+            if pass.id.is_empty() || ids.insert(pass.id.clone(), index).is_some() {
+                return Err("GRAPH_PASS");
+            }
+        }
+        let dependencies = self
+            .passes
+            .iter()
+            .map(|pass| {
+                pass.after
+                    .iter()
+                    .map(|id| ids.get(id).copied().ok_or("GRAPH_DEPENDENCY"))
+                    .collect::<Result<HashSet<_>, _>>()
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        let mut emitted = vec![false; self.passes.len()];
+        let mut order = Vec::with_capacity(self.passes.len());
+        while order.len() < self.passes.len() {
+            let ready = (0..self.passes.len()).find(|&index| {
+                !emitted[index]
+                    && dependencies[index]
+                        .iter()
+                        .all(|dependency| emitted[*dependency])
+            });
+            let index = ready.ok_or("GRAPH_CYCLE")?;
+            emitted[index] = true;
+            order.push(index);
+        }
+        let original = self.passes.clone();
+        self.passes = order
+            .into_iter()
+            .map(|index| original[index].clone())
+            .collect();
+        let sorted_ids: HashMap<_, _> = self
+            .passes
+            .iter()
+            .enumerate()
+            .map(|(index, pass)| (pass.id.clone(), index))
+            .collect();
+        for pass in &mut self.passes {
+            pass.dependencies = pass.after.iter().map(|id| sorted_ids[id]).collect();
+        }
+        self.plan_resources()
+    }
+
+    fn plan_resources(&mut self) -> Result<(), &'static str> {
+        let mut used = HashSet::new();
+        let mut lifetimes = HashMap::new();
+        let mut render_pipelines = HashSet::new();
+        let mut compute_pipelines = HashSet::new();
+        for (frame, pass) in self.passes.iter().enumerate() {
+            match pass.kind.as_str() {
+                "render" => _ = render_pipelines.insert(pass.pipeline.clone()),
+                "compute" => _ = compute_pipelines.insert(pass.pipeline.clone()),
+                _ => return Err("GRAPH_PASS"),
+            }
+            for id in pass.resources() {
+                used.insert(id.to_owned());
+                lifetimes
+                    .entry(id.to_owned())
+                    .and_modify(|range: &mut (usize, usize)| range.1 = frame)
+                    .or_insert((frame, frame));
+            }
+        }
+        self.resources
+            .buffers
+            .retain(|value| used.contains(&value.id));
+        self.resources
+            .samplers
+            .retain(|value| used.contains(&value.id));
+        self.pipelines
+            .render
+            .retain(|value| render_pipelines.contains(&value.id));
+        self.pipelines
+            .compute
+            .retain(|value| compute_pipelines.contains(&value.id));
+
+        let mut textures = self
+            .resources
+            .textures
+            .drain(..)
+            .filter_map(|texture| {
+                lifetimes
+                    .get(&texture.id)
+                    .copied()
+                    .map(|range| (texture, range))
+            })
+            .collect::<Vec<_>>();
+        textures.sort_by_key(|value| value.1 .0);
+        let mut slots: Vec<(String, usize, bool)> = Vec::new();
+        for (texture, (first, last)) in &mut textures {
+            let key = texture.key()?;
+            let reusable = texture
+                .transient
+                .then(|| {
+                    slots
+                        .iter()
+                        .position(|slot| slot.2 && slot.0 == key && slot.1 < *first)
+                })
+                .flatten();
+            texture.slot = match reusable {
+                Some(slot) => {
+                    slots[slot].1 = *last;
+                    slot
+                }
+                None => {
+                    slots.push((key, *last, texture.transient));
+                    slots.len() - 1
+                }
+            };
+        }
+        self.resources.textures = textures.into_iter().map(|value| value.0).collect();
+        self.validate_ids()
+    }
+
+    fn validate_ids(&self) -> Result<(), &'static str> {
+        let mut resources = HashSet::new();
+        for id in self
+            .resources
+            .buffers
+            .iter()
+            .map(|value| &value.id)
+            .chain(self.resources.textures.iter().map(|value| &value.id))
+            .chain(self.resources.samplers.iter().map(|value| &value.id))
+        {
+            if id.is_empty() || !resources.insert(id) {
+                return Err("GRAPH_RESOURCE");
+            }
+        }
+        let mut pipelines = HashSet::new();
+        for id in self
+            .pipelines
+            .render
+            .iter()
+            .map(|value| &value.id)
+            .chain(self.pipelines.compute.iter().map(|value| &value.id))
+        {
+            if id.is_empty() || !pipelines.insert(id) {
+                return Err("GRAPH_PIPELINE");
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Pass {
+    fn resources(&self) -> Vec<&str> {
+        self.bindings
+            .iter()
+            .map(|value| value.resource.as_str())
+            .chain(self.color.iter().map(|value| value.resource.as_str()))
+            .chain(self.depth.iter().map(|value| value.resource.as_str()))
+            .chain(
+                self.vertex_buffers
+                    .iter()
+                    .map(|value| value.resource.as_str()),
+            )
+            .chain(
+                self.index_buffer
+                    .iter()
+                    .map(|value| value.resource.as_str()),
+            )
+            .collect()
+    }
+}
+
+impl Texture {
+    fn key(&self) -> Result<String, &'static str> {
+        let mut usage = self.usage.clone();
+        usage.sort_unstable();
+        usage.dedup();
+        serde_json::to_string(&(
+            &self.size,
+            &self.format,
+            usage,
+            self.mip_level_count,
+            self.sample_count,
+            &self.dimension,
+        ))
+        .map_err(|_| "GRAPH_RESOURCE")
+    }
+}
+
+fn one() -> u32 {
+    1
+}
+fn three() -> u32 {
+    3
+}
+fn one_f32() -> f32 {
+    1.0
+}
+fn yes() -> bool {
+    true
+}
+fn dimension() -> String {
+    "2d".into()
+}
+fn vertex_entry() -> String {
+    "vertex".into()
+}
+fn fragment_entry() -> String {
+    "fragment".into()
+}
+fn compute_entry() -> String {
+    "main".into()
+}
+fn vertex_step() -> String {
+    "vertex".into()
+}
+fn clear_op() -> String {
+    "clear".into()
+}
+fn store_op() -> String {
+    "store".into()
+}
+fn index_format() -> String {
+    "uint32".into()
+}
+fn dispatch() -> [u32; 3] {
+    [1, 1, 1]
+}

core/render_graph/store.rs

@@ -0,0 +1,62 @@
+use std::collections::HashMap;
+
+use crate::gpu::Wgpu;
+use crate::gpu_resource::GpuResources;
+use crate::graph::RenderGraph;
+use crate::render_data::RenderData;
+
+pub struct Loadout {
+    pub graph: RenderGraph,
+    pub resources: GpuResources,
+}
+
+#[derive(Default)]
+pub struct Store {
+    graphs: HashMap<String, RenderGraph>,
+    active: Option<Loadout>,
+}
+
+impl Store {
+    pub fn save(&mut self, graph: RenderGraph) -> String {
+        let id = graph.id.clone();
+        self.graphs.insert(id.clone(), graph);
+        id
+    }
+
+    pub fn switch(&mut self, id: &str, gpu: &Wgpu, data: &RenderData) -> Result<(), String> {
+        let graph = self.graphs.get(id).ok_or("GRAPH_UNKNOWN")?.clone();
+        let resources = GpuResources::activate(&graph, gpu, data)?;
+        self.active = Some(Loadout { graph, resources });
+        Ok(())
+    }
+
+    pub fn active_mut(&mut self) -> Option<&mut Loadout> {
+        self.active.as_mut()
+    }
+
+    pub fn uses_rows(&self, name: &str) -> bool {
+        self.active.as_ref().is_some_and(|active| {
+            active
+                .graph
+                .resources
+                .buffers
+                .iter()
+                .any(|buffer| buffer.array == name)
+        })
+    }
+
+    pub fn refresh_rows(
+        &mut self,
+        name: &str,
+        gpu: &Wgpu,
+        data: &RenderData,
+    ) -> Result<(), String> {
+        if !self.uses_rows(name) {
+            return Ok(());
+        }
+        let graph = self.active.as_ref().unwrap().graph.clone();
+        let resources = GpuResources::activate(&graph, gpu, data)?;
+        self.active = Some(Loadout { graph, resources });
+        Ok(())
+    }
+}

core/renderer/render.rs

@@ -0,0 +1,233 @@
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+
+use gloo_timers::future::TimeoutFuture;
+
+use crate::gpu::Wgpu;
+use crate::gpu_resource::GpuPass;
+use crate::graph::{ColorAttachment, DepthAttachment};
+use crate::render_data::RenderData;
+use crate::store::{Loadout, Store};
+
+pub struct RenderLoop {
+    playing: Cell<bool>,
+    fps: Cell<u32>,
+    started: Cell<bool>,
+    frame: Cell<u32>,
+    elapsed: Cell<f64>,
+    last: Cell<f64>,
+}
+
+impl RenderLoop {
+    pub fn new() -> Self {
+        Self {
+            playing: Cell::new(true),
+            fps: Cell::new(60),
+            started: Cell::new(false),
+            frame: Cell::new(0),
+            elapsed: Cell::new(0.0),
+            last: Cell::new(js_sys::Date::now()),
+        }
+    }
+
+    pub fn play(&self) {
+        self.last.set(js_sys::Date::now());
+        self.playing.set(true);
+    }
+
+    pub fn pause(&self) {
+        self.playing.set(false);
+    }
+
+    pub fn set_fps(&self, fps: u32) -> Result<(), &'static str> {
+        if !(1..=1000).contains(&fps) {
+            return Err("FPS");
+        }
+        self.fps.set(fps);
+        Ok(())
+    }
+
+    pub fn start(
+        self: &Rc<Self>,
+        gpu: Rc<RefCell<Option<Wgpu>>>,
+        store: Rc<RefCell<Store>>,
+        data: Rc<RefCell<RenderData>>,
+    ) {
+        if self.started.replace(true) {
+            return;
+        }
+        let control = self.clone();
+        wasm_bindgen_futures::spawn_local(async move {
+            loop {
+                let started = js_sys::Date::now();
+                if control.playing.get() {
+                    let delta = (started - control.last.replace(started)) / 1000.0;
+                    let elapsed = control.elapsed.get() + delta;
+                    control.elapsed.set(elapsed);
+                    let frame = control.frame.get().wrapping_add(1);
+                    control.frame.set(frame);
+                    let skip = {
+                        let mut data = data.borrow_mut();
+                        data.update_info(delta as f32, frame, elapsed as f32, control.fps.get());
+                        data.skip_render()
+                    };
+                    if !skip {
+                        if let (Some(gpu), Some(loadout)) =
+                            (gpu.borrow_mut().as_mut(), store.borrow_mut().active_mut())
+                        {
+                            let _ = gpu.render(loadout, &data.borrow());
+                        }
+                    }
+                }
+                let target = 1000.0 / f64::from(control.fps.get());
+                let wait = (target - (js_sys::Date::now() - started)).max(0.0) as u32;
+                TimeoutFuture::new(if control.playing.get() { wait } else { 50 }).await;
+            }
+        });
+    }
+}
+
+impl Wgpu {
+    fn render(&mut self, loadout: &mut Loadout, data: &RenderData) -> Result<(), String> {
+        for buffer in loadout.resources.buffers.values() {
+            self.queue.write_buffer(
+                &buffer.buffer,
+                0,
+                data.bytes(&buffer.source).ok_or("ROWS_UNKNOWN")?,
+            );
+        }
+        let output = match self.surface.get_current_texture() {
+            Ok(output) => output,
+            Err(wgpu::SurfaceError::Lost | wgpu::SurfaceError::Outdated) => {
+                self.surface.configure(&self.device, &self.config);
+                self.surface.get_current_texture().map_err(|_| "SURFACE")?
+            }
+            Err(wgpu::SurfaceError::Timeout) => return Ok(()),
+            Err(_) => return Err("SURFACE".into()),
+        };
+        let surface_view = output
+            .texture
+            .create_view(&wgpu::TextureViewDescriptor::default());
+        let mut encoder = self
+            .device
+            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
+                label: Some("frame"),
+            });
+        for (pass, compiled) in loadout.graph.passes.iter().zip(&loadout.resources.passes) {
+            match compiled {
+                GpuPass::Compute {
+                    pipeline,
+                    bind_groups,
+                } => {
+                    let mut command = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
+                        label: Some(&pass.id),
+                        timestamp_writes: None,
+                    });
+                    command.set_pipeline(pipeline);
+                    for (group, bind_group) in bind_groups {
+                        command.set_bind_group(*group, bind_group, &[]);
+                    }
+                    command.dispatch_workgroups(
+                        pass.dispatch[0],
+                        pass.dispatch[1],
+                        pass.dispatch[2],
+                    );
+                }
+                GpuPass::Render(bundle) => {
+                    let colors = pass
+                        .color
+                        .iter()
+                        .map(|attachment| {
+                            Ok(Some(wgpu::RenderPassColorAttachment {
+                                view: view(
+                                    &loadout.resources,
+                                    &surface_view,
+                                    &attachment.resource,
+                                )?,
+                                depth_slice: None,
+                                resolve_target: None,
+                                ops: color_ops(attachment)?,
+                            }))
+                        })
+                        .collect::<Result<Vec<_>, String>>()?;
+                    let depth = pass
+                        .depth
+                        .as_ref()
+                        .map(|attachment| {
+                            Ok::<_, String>(wgpu::RenderPassDepthStencilAttachment {
+                                view: view(
+                                    &loadout.resources,
+                                    &surface_view,
+                                    &attachment.resource,
+                                )?,
+                                depth_ops: Some(depth_ops(attachment)?),
+                                stencil_ops: None,
+                            })
+                        })
+                        .transpose()?;
+                    let mut command = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                        label: Some(&pass.id),
+                        color_attachments: &colors,
+                        depth_stencil_attachment: depth,
+                        timestamp_writes: None,
+                        occlusion_query_set: None,
+                    });
+                    command.execute_bundles([bundle]);
+                }
+            }
+        }
+        self.queue.submit([encoder.finish()]);
+        output.present();
+        Ok(())
+    }
+}
+
+fn view<'a>(
+    resources: &'a crate::gpu_resource::GpuResources,
+    surface: &'a wgpu::TextureView,
+    id: &str,
+) -> Result<&'a wgpu::TextureView, String> {
+    if id == "canvas" {
+        Ok(surface)
+    } else {
+        resources
+            .texture_view(id)
+            .ok_or_else(|| "GRAPH_ATTACHMENT".into())
+    }
+}
+
+fn color_ops(attachment: &ColorAttachment) -> Result<wgpu::Operations<wgpu::Color>, String> {
+    let clear = attachment.clear.as_slice();
+    Ok(wgpu::Operations {
+        load: match attachment.load.as_str() {
+            "load" => wgpu::LoadOp::Load,
+            "clear" => wgpu::LoadOp::Clear(wgpu::Color {
+                r: f64::from(clear.first().copied().unwrap_or(0.0)),
+                g: f64::from(clear.get(1).copied().unwrap_or(0.0)),
+                b: f64::from(clear.get(2).copied().unwrap_or(0.0)),
+                a: f64::from(clear.get(3).copied().unwrap_or(1.0)),
+            }),
+            _ => return Err("GRAPH_LOAD_OP".into()),
+        },
+        store: store_op(&attachment.store)?,
+    })
+}
+
+fn depth_ops(attachment: &DepthAttachment) -> Result<wgpu::Operations<f32>, String> {
+    Ok(wgpu::Operations {
+        load: match attachment.load.as_str() {
+            "load" => wgpu::LoadOp::Load,
+            "clear" => wgpu::LoadOp::Clear(attachment.clear),
+            _ => return Err("GRAPH_LOAD_OP".into()),
+        },
+        store: store_op(&attachment.store)?,
+    })
+}
+
+fn store_op(value: &str) -> Result<wgpu::StoreOp, String> {
+    match value {
+        "store" => Ok(wgpu::StoreOp::Store),
+        "discard" => Ok(wgpu::StoreOp::Discard),
+        _ => Err("GRAPH_STORE_OP".into()),
+    }
+}

core/renderer/wgpu.rs

@@ -0,0 +1,53 @@
+pub struct Wgpu {
+    _instance: wgpu::Instance,
+    pub surface: wgpu::Surface<'static>,
+    pub device: wgpu::Device,
+    pub queue: wgpu::Queue,
+    pub config: wgpu::SurfaceConfiguration,
+    pub format: wgpu::TextureFormat,
+    pub width: u32,
+    pub height: u32,
+}
+
+impl Wgpu {
+    pub async fn new(canvas: web_sys::OffscreenCanvas) -> Result<Self, String> {
+        let width = canvas.width();
+        let height = canvas.height();
+        if width == 0 || height == 0 {
+            return Err("CANVAS_SIZE".into());
+        }
+        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
+            backends: wgpu::Backends::BROWSER_WEBGPU,
+            ..Default::default()
+        });
+        let surface = instance
+            .create_surface(wgpu::SurfaceTarget::OffscreenCanvas(canvas))
+            .map_err(|_| "SURFACE")?;
+        let adapter = instance
+            .request_adapter(&wgpu::RequestAdapterOptions {
+                compatible_surface: Some(&surface),
+                ..Default::default()
+            })
+            .await
+            .map_err(|_| "WEBGPU_UNAVAILABLE")?;
+        let (device, queue) = adapter
+            .request_device(&wgpu::DeviceDescriptor::default())
+            .await
+            .map_err(|_| "DEVICE")?;
+        let config = surface
+            .get_default_config(&adapter, width, height)
+            .ok_or("SURFACE")?;
+        let format = config.format;
+        surface.configure(&device, &config);
+        Ok(Self {
+            _instance: instance,
+            surface,
+            device,
+            queue,
+            config,
+            format,
+            width,
+            height,
+        })
+    }
+}

core/src/lib.rs

@@ -1,424 +0,0 @@
-use std::collections::{HashMap, HashSet};
-
-use serde_json::{Map, Number, Value};
-use wasm_bindgen::prelude::*;
-
-const ALIGNMENT: u32 = 64;
-
-#[wasm_bindgen]
-pub struct Core {
-    _arena: Box<[u8]>,
-    base: u32,
-    capacity: u32,
-    used: u32,
-}
-
-#[wasm_bindgen]
-impl Core {
-    #[wasm_bindgen(constructor)]
-    pub fn new(arena_bytes: u32) -> Result<Self, JsError> {
-        if arena_bytes < ALIGNMENT || arena_bytes > u32::MAX - (ALIGNMENT - 1) {
-            return Err(JsError::new("INIT"));
-        }
-        let mut arena = vec![0; (arena_bytes + ALIGNMENT - 1) as usize].into_boxed_slice();
-        let pointer = arena.as_mut_ptr() as usize;
-        let base = ((pointer + ALIGNMENT as usize - 1) & !(ALIGNMENT as usize - 1)) as u32;
-        Ok(Self {
-            _arena: arena,
-            base,
-            capacity: arena_bytes,
-            used: 0,
-        })
-    }
-
-    pub fn allocate(&mut self, rows: u32, stride: u32, format: &str) -> Result<u32, JsError> {
-        if rows == 0 || stride < 16 || stride % 16 != 0 || !matches!(format, "f32" | "u32" | "i32")
-        {
-            return Err(JsError::new("ALLOCATION"));
-        }
-        let offset = align(self.used, ALIGNMENT).ok_or_else(|| JsError::new("ARENA_OOM"))?;
-        let bytes = rows
-            .checked_mul(stride)
-            .ok_or_else(|| JsError::new("ARENA_OOM"))?;
-        self.used = offset
-            .checked_add(bytes)
-            .filter(|end| *end <= self.capacity)
-            .ok_or_else(|| JsError::new("ARENA_OOM"))?;
-        Ok(self.base + offset)
-    }
-
-    pub fn compile_graph(&self, source: &str) -> Result<String, JsError> {
-        compile_graph(source).map_err(JsError::new)
-    }
-}
-
-fn align(value: u32, alignment: u32) -> Option<u32> {
-    value
-        .checked_add(alignment - 1)
-        .map(|value| value & !(alignment - 1))
-}
-
-enum Expression {
-    Atom(Value),
-    List(Vec<Expression>),
-}
-
-struct Parser<'a> {
-    source: &'a [u8],
-    at: usize,
-}
-
-impl<'a> Parser<'a> {
-    fn parse(source: &'a str) -> Result<Expression, &'static str> {
-        let mut parser = Parser {
-            source: source.as_bytes(),
-            at: 0,
-        };
-        let expression = parser.expression()?;
-        parser.whitespace();
-        if parser.at != parser.source.len() {
-            return Err("GRAPH_WIRE");
-        }
-        Ok(expression)
-    }
-
-    fn expression(&mut self) -> Result<Expression, &'static str> {
-        self.whitespace();
-        match self.source.get(self.at) {
-            Some(b'(') => self.list(),
-            Some(b'"') => self.string(),
-            Some(b')') | None => Err("GRAPH_WIRE"),
-            Some(_) => self.atom(),
-        }
-    }
-
-    fn list(&mut self) -> Result<Expression, &'static str> {
-        self.at += 1;
-        let mut values = Vec::new();
-        loop {
-            self.whitespace();
-            match self.source.get(self.at) {
-                Some(b')') => {
-                    self.at += 1;
-                    return Ok(Expression::List(values));
-                }
-                None => return Err("GRAPH_WIRE"),
-                _ => values.push(self.expression()?),
-            }
-        }
-    }
-
-    fn string(&mut self) -> Result<Expression, &'static str> {
-        let start = self.at;
-        self.at += 1;
-        let mut escaped = false;
-        while let Some(&byte) = self.source.get(self.at) {
-            self.at += 1;
-            if escaped {
-                escaped = false;
-            } else if byte == b'\\' {
-                escaped = true;
-            } else if byte == b'"' {
-                let value = serde_json::from_slice(&self.source[start..self.at])
-                    .map_err(|_| "GRAPH_WIRE")?;
-                return Ok(Expression::Atom(Value::String(value)));
-            }
-        }
-        Err("GRAPH_WIRE")
-    }
-
-    fn atom(&mut self) -> Result<Expression, &'static str> {
-        let start = self.at;
-        while self
-            .source
-            .get(self.at)
-            .is_some_and(|byte| !byte.is_ascii_whitespace() && !matches!(byte, b'(' | b')'))
-        {
-            self.at += 1;
-        }
-        let token = std::str::from_utf8(&self.source[start..self.at]).map_err(|_| "GRAPH_WIRE")?;
-        let value = match token {
-            "true" => Value::Bool(true),
-            "false" => Value::Bool(false),
-            "null" => Value::Null,
-            _ => serde_json::from_str::<Value>(token)
-                .ok()
-                .filter(Value::is_number)
-                .unwrap_or_else(|| Value::String(token.into())),
-        };
-        Ok(Expression::Atom(value))
-    }
-
-    fn whitespace(&mut self) {
-        while self
-            .source
-            .get(self.at)
-            .is_some_and(u8::is_ascii_whitespace)
-        {
-            self.at += 1;
-        }
-    }
-}
-
-fn compile_graph(source: &str) -> Result<String, &'static str> {
-    let root = Parser::parse(source)?;
-    let Expression::List(mut root) = root else {
-        return Err("GRAPH_WIRE");
-    };
-    if root.len() != 3
-        || !matches!(&root[0], Expression::Atom(Value::String(tag)) if tag == "yawn-graph")
-        || !matches!(&root[1], Expression::Atom(Value::Number(version)) if version.as_u64() == Some(1))
-    {
-        return Err("GRAPH_WIRE");
-    }
-    let mut graph = decode(root.pop().unwrap())?;
-    let object = graph.as_object_mut().ok_or("GRAPH_SHAPE")?;
-    if !object.get("id").is_some_and(Value::is_string) {
-        return Err("GRAPH_SHAPE");
-    }
-    let passes = sort_passes(object.get("passes").ok_or("GRAPH_PASS")?)?;
-    plan_resources(object, &passes)?;
-    object.insert("passes".into(), Value::Array(passes));
-    serde_json::to_string(&graph).map_err(|_| "GRAPH_WIRE")
-}
-
-fn decode(expression: Expression) -> Result<Value, &'static str> {
-    let Expression::List(mut values) = expression else {
-        return match expression {
-            Expression::Atom(value) => Ok(value),
-            Expression::List(_) => unreachable!(),
-        };
-    };
-    if values.is_empty() {
-        return Err("GRAPH_WIRE");
-    }
-    let tag = match values.remove(0) {
-        Expression::Atom(Value::String(tag)) => tag,
-        _ => return Err("GRAPH_WIRE"),
-    };
-    if tag == "array" {
-        return values.into_iter().map(decode).collect();
-    }
-    if tag != "object" {
-        return Err("GRAPH_WIRE");
-    }
-    let mut object = Map::new();
-    for field in values {
-        let Expression::List(mut field) = field else {
-            return Err("GRAPH_WIRE");
-        };
-        if field.len() != 3
-            || !matches!(&field[0], Expression::Atom(Value::String(tag)) if tag == "field")
-        {
-            return Err("GRAPH_WIRE");
-        }
-        let value = decode(field.pop().unwrap())?;
-        let key = match field.pop().unwrap() {
-            Expression::Atom(Value::String(key)) => key,
-            _ => return Err("GRAPH_WIRE"),
-        };
-        if object.insert(key, value).is_some() {
-            return Err("GRAPH_WIRE");
-        }
-    }
-    Ok(Value::Object(object))
-}
-
-fn sort_passes(value: &Value) -> Result<Vec<Value>, &'static str> {
-    let passes = value.as_array().ok_or("GRAPH_PASS")?;
-    let mut ids = HashMap::new();
-    for (index, pass) in passes.iter().enumerate() {
-        let id = pass
-            .as_object()
-            .and_then(|pass| pass.get("id"))
-            .and_then(Value::as_str)
-            .ok_or("GRAPH_PASS")?;
-        if ids.insert(id, index).is_some() {
-            return Err("GRAPH_PASS");
-        }
-    }
-    let mut dependencies = Vec::with_capacity(passes.len());
-    for pass in passes {
-        let after = pass.get("after").map_or(Ok(&[][..]), |after| {
-            after.as_array().map(Vec::as_slice).ok_or("GRAPH_ARRAY")
-        })?;
-        dependencies.push(
-            after
-                .iter()
-                .map(|dependency| {
-                    dependency
-                        .as_str()
-                        .and_then(|id| ids.get(id).copied())
-                        .ok_or("GRAPH_DEPENDENCY")
-                })
-                .collect::<Result<HashSet<_>, _>>()?,
-        );
-    }
-    let mut emitted = vec![false; passes.len()];
-    let mut result = Vec::with_capacity(passes.len());
-    while result.len() < passes.len() {
-        let ready = (0..passes.len()).find(|&index| {
-            !emitted[index]
-                && dependencies[index]
-                    .iter()
-                    .all(|dependency| emitted[*dependency])
-        });
-        let index = ready.ok_or("GRAPH_CYCLE")?;
-        emitted[index] = true;
-        result.push(passes[index].clone());
-    }
-    Ok(result)
-}
-
-fn plan_resources(graph: &mut Map<String, Value>, passes: &[Value]) -> Result<(), &'static str> {
-    let mut used = HashSet::new();
-    let mut lifetimes = HashMap::new();
-    for (frame, pass) in passes.iter().enumerate() {
-        for id in pass_resources(pass)? {
-            used.insert(id.to_owned());
-            lifetimes
-                .entry(id.to_owned())
-                .and_modify(|lifetime: &mut (usize, usize)| lifetime.1 = frame)
-                .or_insert((frame, frame));
-        }
-    }
-    let Some(resources) = graph.get_mut("resources") else {
-        return Ok(());
-    };
-    let resources = resources.as_object_mut().ok_or("GRAPH_RESOURCE")?;
-    for kind in ["buffers", "samplers"] {
-        if let Some(declarations) = resources.get_mut(kind) {
-            let declarations = declarations.as_array_mut().ok_or("GRAPH_RESOURCE")?;
-            let mut ids = HashSet::new();
-            declarations.retain(|declaration| {
-                declaration
-                    .get("id")
-                    .and_then(Value::as_str)
-                    .is_some_and(|id| ids.insert(id.to_owned()) && used.contains(id))
-            });
-        }
-    }
-    let Some(textures) = resources.get_mut("textures") else {
-        return Ok(());
-    };
-    let textures = textures.as_array_mut().ok_or("GRAPH_RESOURCE")?;
-    let mut ids = HashSet::new();
-    let mut planned = Vec::new();
-    for mut declaration in textures.drain(..) {
-        let object = declaration.as_object_mut().ok_or("GRAPH_RESOURCE")?;
-        let id = object
-            .get("id")
-            .and_then(Value::as_str)
-            .ok_or("GRAPH_RESOURCE")?;
-        if !ids.insert(id.to_owned()) {
-            return Err("GRAPH_RESOURCE");
-        }
-        let Some(&(first, last)) = lifetimes.get(id) else {
-            continue;
-        };
-        planned.push((declaration, first, last));
-    }
-    planned.sort_by_key(|value| value.1);
-    let mut output = Vec::new();
-    let mut slots: Vec<(String, usize)> = Vec::new();
-    for (mut declaration, first, last) in planned {
-        let object = declaration.as_object_mut().unwrap();
-        let key = texture_key(object)?;
-        let slot = if object.get("transient") == Some(&Value::Bool(false)) {
-            None
-        } else {
-            slots
-                .iter()
-                .position(|value| value.0 == key && value.1 < first)
-        };
-        let slot = match slot {
-            Some(slot) => {
-                slots[slot].1 = last;
-                slot
-            }
-            None => {
-                slots.push((key, last));
-                slots.len() - 1
-            }
-        };
-        object.insert("slot".into(), Value::Number(Number::from(slot as u64)));
-        output.push(declaration);
-    }
-    *textures = output;
-    Ok(())
-}
-
-fn pass_resources(pass: &Value) -> Result<Vec<&str>, &'static str> {
-    let mut result = Vec::new();
-    for field in ["bindings", "color", "vertexBuffers"] {
-        if let Some(values) = pass.get(field) {
-            for value in values.as_array().ok_or("GRAPH_ARRAY")? {
-                result.push(
-                    value
-                        .get("resource")
-                        .and_then(Value::as_str)
-                        .ok_or("GRAPH_RESOURCE")?,
-                );
-            }
-        }
-    }
-    for field in ["depth", "indexBuffer"] {
-        if let Some(value) = pass.get(field) {
-            result.push(
-                value
-                    .get("resource")
-                    .and_then(Value::as_str)
-                    .ok_or("GRAPH_RESOURCE")?,
-            );
-        }
-    }
-    Ok(result)
-}
-
-fn texture_key(texture: &Map<String, Value>) -> Result<String, &'static str> {
-    let mut size = texture.get("size").cloned().unwrap_or_else(|| {
-        Value::Array(vec![
-            Value::String("canvas".into()),
-            Value::String("canvas".into()),
-        ])
-    });
-    let size = size.as_array_mut().ok_or("GRAPH_TEXTURE_SIZE")?;
-    if !(2..=3).contains(&size.len()) {
-        return Err("GRAPH_TEXTURE_SIZE");
-    }
-    if size.len() == 2 {
-        size.push(Value::Number(Number::from(1)));
-    }
-    let format = texture
-        .get("format")
-        .and_then(Value::as_str)
-        .ok_or("GRAPH_RESOURCE")?;
-    let mut usage = texture.get("usage").map_or(Ok(Vec::new()), |usage| {
-        usage
-            .as_array()
-            .ok_or("GRAPH_TEXTURE_USAGE")?
-            .iter()
-            .map(|value| value.as_str().ok_or("GRAPH_TEXTURE_USAGE"))
-            .collect::<Result<Vec<_>, _>>()
-    })?;
-    usage.sort_unstable();
-    usage.dedup();
-    serde_json::to_string(&(
-        size,
-        format,
-        usage,
-        texture
-            .get("mipLevelCount")
-            .and_then(Value::as_u64)
-            .unwrap_or(1),
-        texture
-            .get("sampleCount")
-            .and_then(Value::as_u64)
-            .unwrap_or(1),
-        texture
-            .get("dimension")
-            .and_then(Value::as_str)
-            .unwrap_or("2d"),
-    ))
-    .map_err(|_| "GRAPH_RESOURCE")
-}

core/src/worker.js

@@ -1,221 +0,0 @@
-import initWasm, { Core as WasmCore } from "../pkg/yawn_core.js";
-
-let canvas, context, device, surfaceFormat, memory, core, loadout;
-const arrays = new Map();
-const align = (value, multiple) => Math.ceil(value / multiple) * multiple;
-const fail = code => { throw new Error(code); };
-const list = value => value === undefined ? [] : Array.isArray(value) ? value : fail("GRAPH_ARRAY");
-
-function index(items, code) {
-  const result = new Map();
-  for (const item of list(items)) {
-    if (!item || typeof item.id !== "string" || result.has(item.id)) fail(code);
-    result.set(item.id, item);
-  }
-  return result;
-}
-
-const bufferUsage = names => list(names).reduce((usage, name) => usage | ({
-  uniform: GPUBufferUsage.UNIFORM, storage: GPUBufferUsage.STORAGE,
-  vertex: GPUBufferUsage.VERTEX, index: GPUBufferUsage.INDEX,
-  indirect: GPUBufferUsage.INDIRECT, copySrc: GPUBufferUsage.COPY_SRC,
-}[name] ?? fail("GRAPH_BUFFER_USAGE")), GPUBufferUsage.COPY_DST);
-const textureUsage = names => list(names).reduce((usage, name) => usage | ({
-  render: GPUTextureUsage.RENDER_ATTACHMENT, sampled: GPUTextureUsage.TEXTURE_BINDING,
-  storage: GPUTextureUsage.STORAGE_BINDING, copySrc: GPUTextureUsage.COPY_SRC,
-  copyDst: GPUTextureUsage.COPY_DST,
-}[name] ?? fail("GRAPH_TEXTURE_USAGE")), 0);
-
-async function compile(graph) {
-  if (!graph || typeof graph.id !== "string") fail("GRAPH_SHAPE");
-  const passes = list(graph.passes);
-  const renderDeclarations = index(graph.pipelines?.render, "GRAPH_PIPELINE");
-  const computeDeclarations = index(graph.pipelines?.compute, "GRAPH_PIPELINE");
-  const resources = new Map(), owned = [];
-  try {
-    for (const declaration of list(graph.resources?.buffers)) {
-      const source = arrays.get(declaration.array);
-      if (!source) fail("GRAPH_ARRAY_UNKNOWN");
-      const gpu = device.createBuffer({ size: align(source.bytes, 4), usage: bufferUsage(declaration.usage) });
-      resources.set(declaration.id, { kind: "buffer", gpu, source });
-      owned.push(gpu);
-    }
-
-    const textureSlots = new Map();
-    for (const declaration of list(graph.resources?.textures)) {
-      if (!Number.isInteger(declaration.slot)) fail("GRAPH_RESOURCE");
-      const size = declaration.size ?? ["canvas", "canvas"];
-      if (!Array.isArray(size) || size.length < 2 || size.length > 3) fail("GRAPH_TEXTURE_SIZE");
-      const descriptor = {
-        size: [size[0] === "canvas" ? canvas.width : size[0], size[1] === "canvas" ? canvas.height : size[1], size[2] ?? 1],
-        format: declaration.format,
-        usage: textureUsage(declaration.usage),
-        mipLevelCount: declaration.mipLevelCount ?? 1,
-        sampleCount: declaration.sampleCount ?? 1,
-        dimension: declaration.dimension ?? "2d",
-      };
-      let slot = textureSlots.get(declaration.slot);
-      if (!slot) {
-        const gpu = device.createTexture(descriptor);
-        slot = { gpu, view: gpu.createView() };
-        textureSlots.set(declaration.slot, slot);
-        owned.push(gpu);
-      }
-      resources.set(declaration.id, { kind: "texture", gpu: slot.gpu, view: slot.view });
-    }
-    for (const declaration of list(graph.resources?.samplers))
-      resources.set(declaration.id, {
-        kind: "sampler", gpu: device.createSampler(declaration.descriptor),
-      });
-
-    const renderPipelines = new Map(), computePipelines = new Map();
-    await Promise.all([...new Set(passes.filter(x => x.type === "render").map(x => x.pipeline))].map(async id => {
-      const declaration = renderDeclarations.get(id);
-      if (typeof declaration?.code !== "string") fail("GRAPH_PIPELINE");
-      const module = device.createShaderModule({ code: declaration.code });
-      renderPipelines.set(id, await device.createRenderPipelineAsync({
-        layout: "auto",
-        vertex: { module, entryPoint: declaration.vertex?.entry ?? "vertex", buffers: declaration.vertex?.buffers ?? [] },
-        fragment: {
-          module,
-          entryPoint: declaration.fragment?.entry ?? "fragment",
-          targets: list(declaration.fragment?.targets).map(target => ({
-            ...target, format: target.format === "canvas" ? surfaceFormat : target.format,
-          })),
-        },
-        primitive: declaration.primitive,
-        depthStencil: declaration.depthStencil,
-        multisample: declaration.multisample,
-      }));
-    }));
-    await Promise.all([...new Set(passes.filter(x => x.type === "compute").map(x => x.pipeline))].map(async id => {
-      const declaration = computeDeclarations.get(id);
-      if (typeof declaration?.code !== "string") fail("GRAPH_PIPELINE");
-      const module = device.createShaderModule({ code: declaration.code });
-      computePipelines.set(id, await device.createComputePipelineAsync({
-        layout: "auto", compute: { module, entryPoint: declaration.entry ?? "main" },
-      }));
-    }));
-
-    const bindGroups = (pass, pipeline) => {
-      const groups = new Map();
-      for (const binding of list(pass.bindings)) {
-        const resource = resources.get(binding.resource);
-        if (!resource) fail("GRAPH_RESOURCE_UNKNOWN");
-        const value = resource.kind === "buffer"
-          ? { buffer: resource.gpu, offset: binding.offset ?? 0, ...(binding.size ? { size: binding.size } : {}) }
-          : resource.kind === "texture" ? resource.view : resource.gpu;
-        if (!groups.has(binding.group ?? 0)) groups.set(binding.group ?? 0, []);
-        groups.get(binding.group ?? 0).push({ binding: binding.binding, resource: value });
-      }
-      return [...groups].map(([group, entries]) => [group, device.createBindGroup({
-        layout: pipeline.getBindGroupLayout(group), entries,
-      })]);
-    };
-    const compiled = passes.map(pass => {
-      const pipeline = (pass.type === "render" ? renderPipelines : computePipelines).get(pass.pipeline);
-      if (!pipeline) fail("GRAPH_PASS");
-      return { pass, pipeline, bindGroups: bindGroups(pass, pipeline) };
-    });
-    return { id: graph.id, passes: compiled, resources, owned };
-  } catch (error) {
-    owned.forEach(resource => resource.destroy?.());
-    throw error;
-  }
-}
-
-const clearColor = (value = [0, 0, 0, 1]) => Array.isArray(value)
-  ? { r: value[0], g: value[1], b: value[2], a: value[3] }
-  : value;
-
-function render() {
-  if (!loadout) return;
-  for (const resource of loadout.resources.values())
-    if (resource.kind === "buffer") device.queue.writeBuffer(
-      resource.gpu, 0, new Uint8Array(memory, resource.source.offset, resource.source.bytes),
-    );
-  const encoder = device.createCommandEncoder();
-  for (const { pass, pipeline, bindGroups } of loadout.passes) {
-    if (pass.type === "compute") {
-      const command = encoder.beginComputePass();
-      command.setPipeline(pipeline);
-      bindGroups.forEach(([group, value]) => command.setBindGroup(group, value));
-      command.dispatchWorkgroups(...(pass.dispatch ?? [1, 1, 1]));
-      command.end();
-      continue;
-    }
-    const view = id => id === "canvas"
-      ? context.getCurrentTexture().createView()
-      : loadout.resources.get(id)?.view ?? fail("GRAPH_ATTACHMENT");
-    const command = encoder.beginRenderPass({
-      colorAttachments: list(pass.color).map(attachment => ({
-        view: view(attachment.resource), loadOp: attachment.load ?? "clear",
-        storeOp: attachment.store ?? "store", clearValue: clearColor(attachment.clear),
-      })),
-      ...(pass.depth ? { depthStencilAttachment: {
-        view: view(pass.depth.resource), depthLoadOp: pass.depth.load ?? "clear",
-        depthStoreOp: pass.depth.store ?? "store", depthClearValue: pass.depth.clear ?? 1,
-      } } : {}),
-    });
-    command.setPipeline(pipeline);
-    bindGroups.forEach(([group, value]) => command.setBindGroup(group, value));
-    list(pass.vertexBuffers).forEach(binding => command.setVertexBuffer(
-      binding.slot ?? 0, loadout.resources.get(binding.resource)?.gpu ?? fail("GRAPH_RESOURCE_UNKNOWN"), binding.offset ?? 0,
-    ));
-    if (pass.indexBuffer) command.setIndexBuffer(
-      loadout.resources.get(pass.indexBuffer.resource)?.gpu ?? fail("GRAPH_RESOURCE_UNKNOWN"),
-      pass.indexBuffer.format ?? "uint32", pass.indexBuffer.offset ?? 0,
-    );
-    const draw = pass.draw ?? {};
-    if (pass.indexBuffer) command.drawIndexed(draw.indices ?? 0, draw.instances ?? 1, draw.firstIndex ?? 0, draw.baseVertex ?? 0, draw.firstInstance ?? 0);
-    else command.draw(draw.vertices ?? 3, draw.instances ?? 1, draw.firstVertex ?? 0, draw.firstInstance ?? 0);
-    command.end();
-  }
-  device.queue.submit([encoder.finish()]);
-}
-
-function tick() {
-  try { render(); } catch (error) {
-    postMessage({ type: "runtime-error", error: error?.message ?? "RENDER_ERROR" });
-    loadout = undefined;
-  }
-  (globalThis.requestAnimationFrame ?? (callback => setTimeout(callback, 16)))(tick);
-}
-
-addEventListener("message", async ({ data: message }) => {
-  try {
-    let result;
-    if (message.type === "init") {
-      if (!(message.canvas instanceof OffscreenCanvas) || !Number.isInteger(message.arenaBytes) || message.arenaBytes < 64) fail("INIT");
-      canvas = message.canvas;
-      const wasm = await initWasm();
-      core = new WasmCore(message.arenaBytes);
-      memory = wasm.memory.buffer;
-      if (!(memory instanceof SharedArrayBuffer)) fail("WASM_MEMORY_NOT_SHARED");
-      const adapter = await navigator.gpu?.requestAdapter();
-      if (!adapter) fail("WEBGPU_UNAVAILABLE");
-      device = await adapter.requestDevice();
-      context = canvas.getContext("webgpu");
-      surfaceFormat = navigator.gpu.getPreferredCanvasFormat();
-      context.configure({ device, format: surfaceFormat, alphaMode: "opaque" });
-      device.lost.then(() => { postMessage({ type: "runtime-error", error: "DEVICE_LOST" }); loadout = undefined; });
-      result = { buffer: memory };
-      tick();
-    } else if (message.type === "allocate") {
-      const { name, rows, stride, format } = message;
-      if (typeof name !== "string" || !name || arrays.has(name)) fail("ALLOCATION");
-      const offset = core.allocate(rows, stride, format), bytes = rows * stride;
-      result = { name, rows, stride, format, offset };
-      arrays.set(name, { ...result, bytes });
-    } else if (message.type === "load-graph") {
-      const next = await compile(JSON.parse(core.compile_graph(message.serialized)));
-      const previous = loadout;
-      loadout = next;
-      previous?.owned.forEach(resource => resource.destroy?.());
-      result = { id: next.id };
-    } else fail("MESSAGE");
-    postMessage({ request: message.request, result });
-  } catch (error) {
-    postMessage({ request: message.request, error: error?.message ?? "CORE_ERROR" });
-  }
-});

core/worker.js

@@ -0,0 +1,56 @@
+import initWasm, { Core } from "./pkg/yawn_core.js";
+
+let core;
+
+const fail = code => { throw new Error(code); };
+
+addEventListener("message", async ({ data: message }) => {
+  try {
+    let result;
+    if (message?.type === "init") {
+      if (core || !(message.canvas instanceof OffscreenCanvas)) fail("INIT");
+      const wasm = await initWasm();
+      core = new Core(message.arenaBytes);
+      await core.initialize(message.canvas);
+      const buffer = wasm.memory.buffer;
+      if (!(buffer instanceof SharedArrayBuffer)) fail("WASM_MEMORY_NOT_SHARED");
+      result = { buffer, rows: JSON.parse(core.rows()) };
+    } else {
+      if (!core) fail("UNINITIALIZED");
+      switch (message?.type) {
+        case "create-rows":
+          result = JSON.parse(core.create_rows(message.name, message.rows, message.stride, message.format));
+          break;
+        case "delete-rows":
+          core.delete_rows(message.name);
+          break;
+        case "allocate-object":
+          result = JSON.parse(core.allocate_object(message.name));
+          break;
+        case "delete-object":
+          core.delete_object(message.name, message.id);
+          break;
+        case "compile-graph":
+          result = core.compile_graph(message.serialized);
+          break;
+        case "switch-loadout":
+          core.switch_loadout(message.id);
+          break;
+        case "play":
+          core.play();
+          break;
+        case "pause":
+          core.pause();
+          break;
+        case "set-fps":
+          core.set_fps(message.fps);
+          break;
+        default:
+          fail("MESSAGE");
+      }
+    }
+    postMessage({ request: message.request, result });
+  } catch (error) {
+    postMessage({ request: message?.request, error: error?.message ?? "CORE_ERROR" });
+  }
+});