webvas 0.1.0 → 0.3.0

data/js/loader.js

@@ -6,6 +6,7 @@
   const runtimeUrl = loader.dataset.runtime || new URL("./assets/webvas.wasm", base).href;
   const workerUrl = new URL("./worker.js", base).href;
   const bridgeUrl = new URL("./bridge.js", base).href;
+  const shaderUrl = new URL("./wgsl-runner.js", base).href;
 
   async function run(sourceElement) {
     const selector = sourceElement.dataset.canvas || "#screen";
@@ -19,22 +20,35 @@
     canvas.insertAdjacentElement("afterend", status);
     const report = message => { status.textContent = message; };
     report("Loading Ruby runtime…");
+
+    const gpu = document.querySelector("#gpu") || document.createElement("canvas");
+    gpu.hidden = true;
+    if (!gpu.isConnected) {
+      gpu.id = "gpu";
+      gpu.hidden = true;
+      canvas.insertAdjacentElement("afterend", gpu);
+    }
     if (canvas.tabIndex < 0) canvas.tabIndex = 0;
 
     const response = await fetch(workerUrl, { credentials: "omit" });
     if (!response.ok) throw new Error(`Worker download failed: ${response.status}`);
     const workerBlobUrl = URL.createObjectURL(new Blob([await response.text()], { type: "text/javascript" }));
     const worker = new Worker(workerBlobUrl, { type: "module", name: "webvas" });
+    const screenSelector = selector;
     worker.addEventListener("message", event => {
       const message = event.data || {};
       if (message.type === "webvas:loading") report(message.message || "Loading Ruby runtime…");
       else if (message.type === "webvas:ready") {
         URL.revokeObjectURL(workerBlobUrl);
         worker.postMessage({ type: "webvas:run", source: sourceElement.textContent });
-      } else if (message.type === "webvas:started") report("Ruby sketch is running");
+      }
+      else if (message.type === "webvas:started") report("Ruby sketch is running");
       else if (message.type === "webvas:error") report([message.message, message.backtrace].filter(Boolean).join("\n"));
-      else if (message.type === "webvas:pixelated" && message.selector === selector) {
+      else if (message.type === "webvas:pixelated" && message.selector === screenSelector) {
         canvas.style.imageRendering = message.enabled ? "pixelated" : "auto";
+      } else if (message.type === "webvas:mode") {
+        canvas.hidden = message.canvas !== screenSelector;
+        gpu.hidden = message.canvas !== "#gpu";
       }
     });
     worker.addEventListener("error", event => {
@@ -44,12 +58,11 @@
 
     const forward = event => {
       if (event.type === "wheel") event.preventDefault();
-      if (event.type === "keydown" && event.code === "Space") event.preventDefault();
       if (event.type === "pointerdown") {
         canvas.focus({ preventScroll: true });
         canvas.setPointerCapture(event.pointerId);
       }
-      const rect = canvas.getBoundingClientRect();
+      const rect = event.currentTarget.getBoundingClientRect();
       worker.postMessage({
         type: "webvas:input",
         event: {
@@ -66,11 +79,12 @@
       canvas.addEventListener(type, forward, type === "wheel" ? { passive: false } : undefined);
     }
 
-    const offscreen = canvas.transferControlToOffscreen();
+    const screen = canvas.transferControlToOffscreen();
+    const gpuCanvas = gpu.transferControlToOffscreen();
     worker.postMessage({
-      type: "webvas:init", canvas: offscreen, selector,
-      bridgeUrl, wasmUrl: new URL(runtimeUrl, document.baseURI).href
-    }, [offscreen]);
+      type: "webvas:init", screen, gpu: gpuCanvas, screenSelector, gpuSelector: "#gpu",
+      bridgeUrl, shaderUrl, wasmUrl: new URL(runtimeUrl, document.baseURI).href
+    }, [screen, gpuCanvas]);
   }
 
   const start = () => document.querySelectorAll('script[type="text/ruby"][data-webvas]').forEach(element => {

data/lib/webvas/bridge.rb

@@ -37,5 +37,10 @@ module Webvas
     def show_error(message, backtrace)
       @api.showError(String(message), Array(backtrace).join("\n"))
     end
+
+    def run_shader(canvas, source, layout, uniforms)
+      @api.shaderMode(canvas)
+      JS.global[:GlazeWGSL].run(canvas, source, layout, uniforms)
+    end
   end
 end

data/lib/webvas/shader.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Webvas
+  class Shader
+    DEFAULT_LAYOUT = {
+      fields: {
+        resolution: { offset: 0, type: :vec2 },
+        time: { offset: 8, type: :float },
+        frame: { offset: 12, type: :int },
+        mouse: { offset: 16, type: :vec4 }
+      },
+      size: 32
+    }.freeze
+
+    attr_reader :source, :canvas, :layout
+
+    def initialize(source, canvas: "#screen", layout: nil)
+      @source = String(source)
+      @canvas = String(canvas)
+      @layout = layout || DEFAULT_LAYOUT
+    end
+
+    def run(canvas: @canvas, bridge: Bridge.new, &uniforms)
+      stop
+      callback = proc { |time| JSON.generate(uniforms ? uniforms.call(Float(time)) : {}) }
+      @runner = bridge.run_shader(String(canvas), @source, JSON.generate(@layout), callback)
+    end
+
+    def stop
+      @runner.stop if @runner
+      @runner = nil
+    end
+  end
+end

data/lib/webvas/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Webvas
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/webvas.rb

@@ -7,6 +7,7 @@ require_relative "webvas/backend"
 require_relative "webvas/input"
 require_relative "webvas/key_map"
 require_relative "webvas/runner"
+require_relative "webvas/shader"
 
 module Webvas
   class Error < StandardError; end
@@ -36,4 +37,9 @@ module Webvas
     Bridge.new.show_error(error.message, error.backtrace || [])
   end
 
+  def self.run_shader(shader, canvas: "#gpu", &uniforms)
+    raise ArgumentError, "shader must be a Webvas::Shader" unless shader.is_a?(Shader)
+
+    shader.run(canvas:, &uniforms)
+  end
 end

data/patches/psych-wasi.patch

@@ -0,0 +1,9 @@
+--- a/ext/psych/extconf.rb
++++ b/ext/psych/extconf.rb
+@@ -40,3 +40,3 @@
+   # default to pre-installed libyaml
+-elsif pkg_config('yaml-0.1')
++elsif !CROSS_COMPILING && pkg_config('yaml-0.1')
+   # found with pkg-config
+ else
+   dir_config('libyaml')

data/runtime/Gemfile

@@ -0,0 +1,22 @@
+source "https://rubygems.org"
+
+gem "ruby_wasm", "~> 2.10.1"
+gem "js", "~> 2.10.1"
+
+[
+  ["webvas", ".."],
+  ["glaze", "../../glaze"],
+  ["gesso", "../../gesso"],
+  ["glyphic", "../../glyphic"],
+  ["larb", "../../larb"],
+  ["rbgl", "../../rbgl"],
+  ["rlsl", "../../rlsl"],
+  ["tessel", "../../tessel"]
+].each do |name, relative_path|
+  path = File.expand_path(relative_path, __dir__)
+  if File.file?(File.join(path, "#{name}.gemspec"))
+    gem name, path: path
+  else
+    gem name
+  end
+end

data/runtime/Gemfile.lock

@@ -0,0 +1,101 @@
+PATH
+  remote: ../../gesso
+  specs:
+    gesso (0.1.0)
+      glyphic (>= 0.1.0)
+      larb (>= 1.0.0)
+      rbgl (>= 1.0.0)
+      rlsl (>= 1.0.0)
+      tessel (>= 0.1.0)
+
+PATH
+  remote: ../../glaze
+  specs:
+    glaze (0.1.0)
+      rbgl (>= 1.0.0)
+      rlsl (>= 1.0.0)
+      tessel (>= 0.1.0)
+
+PATH
+  remote: ../../glyphic
+  specs:
+    glyphic (0.1.0)
+      tessel (>= 0.1.0)
+
+PATH
+  remote: ../../larb
+  specs:
+    larb (1.0.1)
+
+PATH
+  remote: ../../rbgl
+  specs:
+    rbgl (1.0.0)
+      larb (~> 1.0)
+
+PATH
+  remote: ../../rlsl
+  specs:
+    rlsl (1.0.0)
+      prism (>= 1.0.0)
+
+PATH
+  remote: ../../tessel
+  specs:
+    tessel (0.2.0)
+
+PATH
+  remote: ..
+  specs:
+    webvas (0.3.0)
+      base64 (~> 0.2)
+      glaze (>= 0.1.0, < 0.2)
+      rbgl (>= 1.0.0, < 2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    base64 (0.3.0)
+    js (2.10.1)
+    logger (1.7.0)
+    prism (1.9.0)
+    ruby_wasm (2.10.1-arm64-darwin)
+      logger
+    ruby_wasm (2.10.1-x86_64-linux)
+      logger
+
+PLATFORMS
+  arm64-darwin-24
+  arm64-darwin-25
+  x86_64-linux
+
+DEPENDENCIES
+  gesso!
+  glaze!
+  glyphic!
+  js (~> 2.10.1)
+  larb!
+  rbgl!
+  rlsl!
+  ruby_wasm (~> 2.10.1)
+  tessel!
+  webvas!
+
+CHECKSUMS
+  base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
+  gesso (0.1.0)
+  glaze (0.1.0)
+  glyphic (0.1.0)
+  js (2.10.1) sha256=c5fb88c60ea936234f818ff240f2ab0c42a57c25ab9b575211fcc4d702d059fb
+  larb (1.0.1)
+  logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
+  prism (1.9.0) sha256=7b530c6a9f92c24300014919c9dcbc055bf4cdf51ec30aed099b06cd6674ef85
+  rbgl (1.0.0)
+  rlsl (1.0.0)
+  ruby_wasm (2.10.1-arm64-darwin) sha256=f106a9b4d8b273592471005460f8c54d89a8913e4fecb9dbab3bd3fc8c20bbc6
+  ruby_wasm (2.10.1-x86_64-linux) sha256=728e29dc688246572b56dcef1c7b131431d07865320c9b8434dd1ccdfd63db2b
+  tessel (0.2.0)
+  webvas (0.3.0)
+
+BUNDLED WITH
+   2.6.9

data/script/build_site

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "fileutils"
+require "cgi"
+require "rubygems"
+require "uri"
+require "zlib"
+
+root = File.expand_path("..", __dir__)
+destination = File.expand_path(ARGV.fetch(0, File.join(root, "public")))
+runtime_url = ARGV.fetch(1, "./assets/webvas.wasm")
+wasm = ARGV[2] || File.join(root, "build", "webvas.wasm")
+uri = URI.parse(runtime_url)
+if uri.host && (uri.scheme != "https" || uri.userinfo)
+  abort "Runtime URL must use HTTPS"
+end
+glaze_runner = File.expand_path("../glaze/lib/glaze/webgpu_runner.js", root)
+unless File.file?(glaze_runner)
+  glaze = Gem::Specification.find_by_name("glaze")
+  glaze_runner = File.join(glaze.full_gem_path, "lib", "glaze", "webgpu_runner.js")
+end
+
+abort "Build the WebAssembly runtime first: #{wasm}" if runtime_url.start_with?(".", "/") && !File.file?(wasm)
+abort "Missing shared Glaze WebGPU runner: #{glaze_runner}" unless File.file?(glaze_runner)
+
+FileUtils.rm_rf(destination)
+FileUtils.cp_r(File.join(root, "site"), destination)
+FileUtils.cp(File.join(root, "js", "bridge.js"), File.join(destination, "bridge.js"))
+FileUtils.cp(File.join(root, "js", "loader.js"), File.join(destination, "loader.js"))
+FileUtils.cp(glaze_runner, File.join(destination, "wgsl-runner.js"))
+index = File.join(destination, "index.html")
+html = File.read(index)
+html.sub!(%r{(<meta name="webvas-runtime" content=")[^"]*(">)}, "\\1#{CGI.escapeHTML(runtime_url)}\\2")
+if uri.host
+  html.sub!(/connect-src ([^;]+)/) do
+    sources = Regexp.last_match(1)
+    "connect-src #{sources} https://#{uri.host}"
+  end
+end
+File.write(index, html)
+
+if runtime_url.start_with?(".", "/")
+  abort "Build the WebAssembly runtime first: #{wasm}" unless File.file?(wasm)
+  FileUtils.mkdir_p(File.join(destination, "assets"))
+  FileUtils.cp(wasm, File.join(destination, "assets", "webvas.wasm"))
+  raw_size = File.size(wasm)
+  compressed_size = Zlib::Deflate.deflate(File.binread(wasm), Zlib::BEST_COMPRESSION).bytesize
+  puts "Webvas runtime: #{raw_size} bytes (#{compressed_size} deflate bytes)"
+else
+  puts "Webvas runtime: #{runtime_url}"
+end

data/sig/webvas.rbs

@@ -13,6 +13,7 @@ module Webvas
     def close: (untyped handle) -> untyped
     def request_animation_frame: (Proc callback) -> untyped
     def show_error: (String message, Array[String] backtrace) -> untyped
+    def run_shader: (String canvas, String source, String layout, Proc uniforms) -> untyped
   end
 
   class Backend < RBGL::GUI::Backend
@@ -43,6 +44,16 @@ module Webvas
     def request_animation_frame: (Proc callback) -> untyped
   end
 
+  class Shader
+    attr_reader source: String
+    attr_reader canvas: String
+    attr_reader layout: Hash[Symbol, untyped]
+    def initialize: (String source, ?canvas: String, ?layout: Hash[Symbol, untyped]) -> void
+    def run: (?canvas: String, ?bridge: Bridge) ?{ (Float) -> Hash[Symbol, untyped] } -> untyped
+    def stop: () -> nil
+  end
+
   def self.run: (RBGL::GUI::Window window, ?scheduler: Scheduler, ?on_error: Proc) { (RBGL::Engine::Context, Float) -> void } -> Proc
+  def self.run_shader: (Shader shader, ?canvas: String) ?{ (Float) -> Hash[Symbol, untyped] } -> untyped
   def self.report_error: (StandardError error) -> untyped
 end