substrate-lang 0.10.0 → 0.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "substrate-lang",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "A Lisp for writing WebAssembly, and the substrate command that builds, runs and tests it",
   "license": "MIT",
   "repository": {

package/std/package.sub

@@ -1,6 +1,6 @@
 (package std
-  (version "0.10.0")
-  (substrate "0.10.0")
+  (version "0.10.1")
+  (substrate "0.10.1")
   (exports archive/tar browser/chromium browser/devtools compress/deflate compress/gzip compress/inflate crypto/hmac
            crypto/password crypto/sha1
            crypto/sha256 crypto/sha512 doc/doc doc/html doc/root doc/text encoding/base64 encoding/json encoding/utf8
@@ -8,6 +8,7 @@
            http/route http/server http/session http/sse http/sse-client http/static http/test http/token http/url
            http/websocket log/log meta/derive meta/equal meta/method meta/type-info package/files package/hash
            package/manifest package/map package/pack package/path package/read package/site package/store test/browser
-           test/build test/run test/session test/test vector/vector web/canvas web/dom web/gpu web/patches)
+           test/build test/run test/session test/test vector/vector web/canvas web/dom web/gpu web/gpu-commands
+           web/patches)
   (tests "tests/archive/*.sub" "tests/compress/*.sub" "tests/crypto/*.sub" "tests/encoding/*.sub" "tests/http/*.sub"
          "tests/log/*.sub" "tests/meta/*.sub" "tests/test/*.sub" "tests/vector/*.sub"))

package/std/web/canvas.sub

@@ -15,7 +15,7 @@
 (define begun u32 0)
 
 (define (canvas-begin! [node u32])
-  (words! (slice (array-of u32 13 node 0)))
+  (words! (slice (array-of u32 11 node 0)))
   (set! drawing (-> (dom-patches) length))
   (set! begun (dom-flushes)))
 
@@ -90,12 +90,12 @@
 
 (define next-image u32 1)
 
-(define (canvas-load-image! [path string]) -> u32
+(define (canvas-load-image! [path string] [tag (ptr void)]) -> u32
   (if (canvas-drawing?)
       0
       (let ([id next-image])
         (+= next-image 1)
-        (dom-image! id path)
+        (dom-image! id path tag)
         id)))
 
 (define (canvas-draw-sprite! [image u32] [cell-width f64] [cell-height f64] [frame u32] [x f64] [y f64] [flip bool])

package/std/web/dom.sub

@@ -1,9 +1,25 @@
-;; The page: the host module "dom" and the patches that patches.sub writes. dom-flush! sends the patches, and
-;; dom-event-text and dom-event-truths read the current event.
+;; The page: the host module "dom" and the patches that patches.sub writes. dom-flush! sends the patches. A read takes a
+;; name that walks from a node, or from the current event, through the page's objects: a property's name, or names
+;; joined by dots. It gives a number, with true as 1, or text. The text lasts until the patches are sent. dom-is and
+;; dom-event-is also take a node, and say whether the name leads to it. (dom-is node dom-document "activeElement") says
+;; whether the node has the focus. dom-event-call calls a method of the current event.
 (require-unqualified host-dom host/web/dom)
 (require-unqualified patches "patches.sub")
 
-(provide (all-from-out host-dom) (all-from-out patches) dom-flush! dom-event-text dom-event-truths)
+(provide (all-from-out host-dom) (all-from-out patches) dom-flush! dom-element dom-event-number dom-event-text
+         dom-event-call dom-event-is dom-read-number dom-read-text dom-is)
+
+(import event-number "dom" "event_number" (i32 i32 -> f64))
+(import event-text "dom" "event_text" (i32 i32 i32 -> i32))
+(import event-call "dom" "event_call" (i32 i32 ->))
+(import event-is "dom" "event_is" (i32 i32 i32 -> i32))
+(import read-number "dom" "read_number" (i32 i32 i32 -> f64))
+(import read-text "dom" "read_text" (i32 i32 i32 i32 -> i32))
+(import is "dom" "is" (i32 i32 i32 i32 -> i32))
+
+(define (dom-element [id string]) -> u32
+  (let ([n (dom-new-node!)])
+    (if (== (dom-bind-element (cast i32 (-> id bytes)) (cast i32 (-> id length)) (cast i32 n)) 0) 0 n)))
 
 (define (dom-flush!)
   (let* ([b (dom-patches)] [n (-> b length)])
@@ -12,12 +28,30 @@
       (dom-apply (cast i32 (-> b bytes)) n))
     (dom-discard!)))
 
-;; The current event's text: its target's value when which is 0, or its key when which is 1.
-(define (dom-event-text [which u32]) -> string
-  (let* ([n u32 0] [s (cast (ptr u8) (if (== which 0) (dom-event-value (cast i32 (& n))) (dom-event-key (cast i32 (& n)))))]
-         [p (cast (ptr u8) (dom-frame-alloc n))])
-    (memcpy p s n)
-    (free s)
-    (cast string (slice p n))))
+(define (kept-text [p (ptr u8)] [n u32]) -> string
+  (let ([copy (cast (ptr u8) (dom-frame-alloc n))])
+    (memcpy copy p n)
+    (free p)
+    (cast string (slice copy n))))
+
+(define (dom-event-number [path string]) -> f64 (event-number (cast i32 (-> path bytes)) (cast i32 (-> path length))))
+
+(define (dom-event-text [path string]) -> string
+  (let* ([n u32 0] [p (event-text (cast i32 (-> path bytes)) (cast i32 (-> path length)) (cast i32 (& n)))])
+    (kept-text (cast (ptr u8) p) n)))
+
+(define (dom-event-call [method string]) (event-call (cast i32 (-> method bytes)) (cast i32 (-> method length))))
+
+(define (dom-read-number [node u32] [path string]) -> f64
+  (read-number (cast i32 node) (cast i32 (-> path bytes)) (cast i32 (-> path length))))
+
+(define (dom-read-text [node u32] [path string]) -> string
+  (let* ([n u32 0]
+         [p (read-text (cast i32 node) (cast i32 (-> path bytes)) (cast i32 (-> path length)) (cast i32 (& n)))])
+    (kept-text (cast (ptr u8) p) n)))
+
+(define (dom-event-is [node u32] [path string]) -> bool
+  (!= (event-is (cast i32 node) (cast i32 (-> path bytes)) (cast i32 (-> path length))) 0))
 
-(define (dom-event-truths) -> u32 (cast u32 (dom-event-flags)))
+(define (dom-is [node u32] [from u32] [path string]) -> bool
+  (!= (is (cast i32 node) (cast i32 from) (cast i32 (-> path bytes)) (cast i32 (-> path length))) 0))

package/std/web/gpu-commands.sub

@@ -0,0 +1,439 @@
+;; The commands of the host module "gpu", written into one buffer. gpu.sub sends them.
+(provide gpu-surface! gpu-shader! gpu-render-pipeline! gpu-layout-item! gpu-target! gpu-vertex-buffer-layout! gpu-attribute!
+         gpu-compute-pipeline! gpu-buffer! gpu-texture! gpu-texture-file! gpu-sampler! gpu-layout! gpu-layout-entry!
+         gpu-bind-group! gpu-bind-buffer! gpu-bind-sampler! gpu-bind-texture! gpu-destroy!
+         gpu-write-buffer! gpu-write-texture! gpu-read-texture! gpu-read-buffer!
+         gpu-render-pass! gpu-pass-target! gpu-compute-pass! gpu-end-pass! gpu-pipeline! gpu-bind-group-set! gpu-offset!
+         gpu-vertex-buffer! gpu-index-buffer! gpu-draw! gpu-draw-indexed! gpu-dispatch! gpu-viewport! gpu-scissor!
+         gpu-commands gpu-commands-done! gpu-frame-alloc gpu-frame-copy
+         gpu-format-surface gpu-rgba8 gpu-bgra8 gpu-r8 gpu-rg8 gpu-rgba16f gpu-r32f gpu-rgba32f gpu-depth24 gpu-depth32f
+         gpu-f32 gpu-f32x2 gpu-f32x3 gpu-f32x4 gpu-u32 gpu-u32x2 gpu-u32x4 gpu-i32 gpu-unorm8x4 gpu-snorm8x4
+         gpu-f16x2 gpu-f16x4 gpu-u8x4 gpu-unorm16x2 gpu-unorm16x4
+         gpu-triangles gpu-triangle-strip gpu-lines gpu-line-strip gpu-points
+         gpu-cull-none gpu-cull-back gpu-cull-front gpu-ccw gpu-cw
+         gpu-blend-none gpu-blend-alpha gpu-blend-premultiplied gpu-blend-add
+         gpu-compare-none gpu-less gpu-less-equal gpu-greater gpu-greater-equal gpu-equal gpu-always gpu-never
+         gpu-vertex gpu-index gpu-uniform gpu-storage gpu-indirect gpu-sampled gpu-target gpu-storage-texture
+         gpu-nearest gpu-linear gpu-clamp gpu-repeat gpu-mirror
+         gpu-uniform-entry gpu-storage-entry gpu-read-only-entry gpu-dynamic-uniform-entry gpu-dynamic-storage-entry
+         gpu-dynamic-read-only-entry gpu-sampler-entry gpu-comparison-entry gpu-texture-entry gpu-depth-entry
+         gpu-storage-texture-entry gpu-texture-array-entry gpu-depth-array-entry gpu-in-vertex gpu-in-fragment gpu-in-compute
+         gpu-per-vertex gpu-per-instance gpu-on-surface gpu-on-texture gpu-keep gpu-clear gpu-u16-indexes gpu-u32-indexes
+         gpu-kind-surface gpu-kind-shader gpu-kind-pipeline gpu-kind-buffer gpu-kind-texture gpu-kind-sampler
+         gpu-kind-layout gpu-kind-bind-group)
+
+;; ---- the codes ----
+
+;; Each code is the number host/web/gpu.mjs gives it.
+(const gpu-format-surface u32 0)
+(const gpu-rgba8 u32 1)
+(const gpu-bgra8 u32 2)
+(const gpu-r8 u32 3)
+(const gpu-rg8 u32 4)
+(const gpu-rgba16f u32 5)
+(const gpu-r32f u32 6)
+(const gpu-rgba32f u32 7)
+(const gpu-depth24 u32 8)
+(const gpu-depth32f u32 9)
+
+(const gpu-f32 u32 1)
+(const gpu-f32x2 u32 2)
+(const gpu-f32x3 u32 3)
+(const gpu-f32x4 u32 4)
+(const gpu-u32 u32 5)
+(const gpu-u32x2 u32 6)
+(const gpu-u32x4 u32 7)
+(const gpu-i32 u32 8)
+(const gpu-unorm8x4 u32 9)
+(const gpu-snorm8x4 u32 10)
+(const gpu-f16x2 u32 11)
+(const gpu-f16x4 u32 12)
+(const gpu-u8x4 u32 13)
+(const gpu-unorm16x2 u32 14)
+(const gpu-unorm16x4 u32 15)
+
+(const gpu-triangles u32 1)
+(const gpu-triangle-strip u32 2)
+(const gpu-lines u32 3)
+(const gpu-line-strip u32 4)
+(const gpu-points u32 5)
+
+(const gpu-cull-none u32 0)
+(const gpu-cull-back u32 1)
+(const gpu-cull-front u32 2)
+(const gpu-ccw u32 0)
+(const gpu-cw u32 1)
+
+(const gpu-blend-none u32 0)
+(const gpu-blend-alpha u32 1)
+(const gpu-blend-premultiplied u32 2)
+(const gpu-blend-add u32 3)
+
+(const gpu-compare-none u32 0)
+(const gpu-less u32 1)
+(const gpu-less-equal u32 2)
+(const gpu-greater u32 3)
+(const gpu-greater-equal u32 4)
+(const gpu-equal u32 5)
+(const gpu-always u32 6)
+(const gpu-never u32 7)
+
+(const gpu-vertex u32 1)
+(const gpu-index u32 2)
+(const gpu-uniform u32 4)
+(const gpu-storage u32 8)
+(const gpu-indirect u32 16)
+(const gpu-sampled u32 1)
+(const gpu-target u32 2)
+(const gpu-storage-texture u32 4)
+
+(const gpu-nearest u32 0)
+(const gpu-linear u32 1)
+(const gpu-clamp u32 0)
+(const gpu-repeat u32 1)
+(const gpu-mirror u32 2)
+
+(const gpu-uniform-entry u32 1)
+(const gpu-storage-entry u32 2)
+(const gpu-read-only-entry u32 3)
+(const gpu-dynamic-uniform-entry u32 4)
+(const gpu-dynamic-storage-entry u32 5)
+(const gpu-dynamic-read-only-entry u32 6)
+(const gpu-sampler-entry u32 7)
+(const gpu-comparison-entry u32 8)
+(const gpu-texture-entry u32 9)
+(const gpu-depth-entry u32 10)
+(const gpu-storage-texture-entry u32 11)
+(const gpu-texture-array-entry u32 12)
+(const gpu-depth-array-entry u32 13)
+(const gpu-in-vertex u32 1)
+(const gpu-in-fragment u32 2)
+(const gpu-in-compute u32 4)
+
+(const gpu-per-vertex u32 0)
+(const gpu-per-instance u32 1)
+(const gpu-on-surface u32 1)
+(const gpu-on-texture u32 2)
+(const gpu-keep u32 0)
+(const gpu-clear u32 1)
+(const gpu-u16-indexes u32 0)
+(const gpu-u32-indexes u32 1)
+
+(const gpu-kind-surface u32 1)
+(const gpu-kind-shader u32 2)
+(const gpu-kind-pipeline u32 3)
+(const gpu-kind-buffer u32 4)
+(const gpu-kind-texture u32 5)
+(const gpu-kind-sampler u32 6)
+(const gpu-kind-layout u32 7)
+(const gpu-kind-bind-group u32 8)
+
+;; ---- the buffer ----
+
+(define commands buffer)
+(define frame arena)
+
+(define (gpu-commands) -> (ptr buffer)
+  (complete!)
+  (& commands))
+
+(define (gpu-commands-done!)
+  (set! (-> commands length) 0)
+  (arena-free (& frame))
+  (expect-nothing!))
+
+(define (gpu-frame-alloc [n u32]) -> (ptr void) (arena-alloc (& frame) n))
+
+(define (gpu-frame-copy [p (ptr void)] [n u32]) -> (ptr void)
+  (let ([copy (gpu-frame-alloc n)])
+    (memcpy copy p n)
+    copy))
+
+(define (words! [w (slice u32)]) (buffer-add! (& commands) (slice (cast (ptr u8) (-> w items)) (* 4 (-> w length)))))
+
+(define (word! [w u32]) (words! (slice (array-of u32 w))))
+
+(define (float! [x f64]) (buffer-add! (& commands) (slice (cast (ptr u8) (array-of f32 (cast f32 x))) 4)))
+
+(define (text! [s string])
+  (let ([copy (cast (ptr u8) (gpu-frame-alloc (-> s length)))])
+    (memcpy copy (-> s bytes) (-> s length))
+    (words! (slice (array-of u32 (cast u32 copy) (-> s length))))))
+
+;; ---- the items a command still expects ----
+
+(define expected-layouts u32 0)
+(define expected-targets u32 0)
+(define expected-buffers u32 0)
+(define expected-attributes u32 0)
+(define expected-entries u32 0)
+(define expected-bindings u32 0)
+(define expected-pass-targets u32 0)
+(define expected-offsets u32 0)
+
+(define (complete!)
+  (when (or (> expected-layouts 0) (> expected-targets 0) (> expected-buffers 0) (> expected-attributes 0)
+            (> expected-entries 0) (> expected-bindings 0) (> expected-pass-targets 0) (> expected-offsets 0))
+    (host-trap "gpu: the last command is still waiting for its items (layouts, targets, attributes, entries or offsets)")))
+
+(define (expect-nothing!)
+  (set! expected-layouts 0)
+  (set! expected-targets 0)
+  (set! expected-buffers 0)
+  (set! expected-attributes 0)
+  (set! expected-entries 0)
+  (set! expected-bindings 0)
+  (set! expected-pass-targets 0)
+  (set! expected-offsets 0))
+
+(define (item! [expected (ptr u32)] [unexpected string])
+  (when (== (@ expected) 0) (host-trap unexpected))
+  (-= (@ expected) 1))
+
+;; ---- numbers ----
+
+(define next-surface u32 1)
+(define next-shader u32 1)
+(define next-pipeline u32 1)
+(define next-buffer u32 1)
+(define next-texture u32 1)
+(define next-sampler u32 1)
+(define next-layout u32 1)
+(define next-bind-group u32 1)
+
+(define (fresh! [next (ptr u32)]) -> u32
+  (let ([n (@ next)])
+    (+= (@ next) 1)
+    n))
+
+;; ---- making resources ----
+
+(define (gpu-surface! [node u32]) -> u32
+  (complete!)
+  (let ([id (fresh! (& next-surface))])
+    (words! (slice (array-of u32 1 id node)))
+    id))
+
+(define (gpu-shader! [code string]) -> u32
+  (complete!)
+  (let ([id (fresh! (& next-shader))])
+    (words! (slice (array-of u32 2 id)))
+    (text! code)
+    id))
+
+(define (gpu-render-pipeline! [shader u32] [vertex string] [fragment string] [topology u32] [cull u32] [front u32]
+                              [blend u32] [depth-format u32] [depth-compare u32] [depth-write bool]
+                              [layouts u32] [targets u32] [buffers u32]) -> u32
+  (complete!)
+  (let ([id (fresh! (& next-pipeline))])
+    (words! (slice (array-of u32 3 id shader)))
+    (text! vertex)
+    (text! fragment)
+    (words! (slice (array-of u32 topology cull front blend depth-format depth-compare depth-write layouts)))
+    (set! expected-layouts layouts)
+    (set! expected-targets targets)
+    (set! expected-buffers buffers)
+    (set! rendering #t)
+    (when (== layouts 0) (after-layouts!))
+    id))
+
+(define rendering bool #f)
+
+(define (after-layouts!)
+  (when rendering
+    (word! expected-targets)
+    (when (== expected-targets 0) (after-targets!))))
+
+(define (after-targets!) (word! expected-buffers))
+
+(define (gpu-layout-item! [layout u32])
+  (item! (& expected-layouts) "gpu: no layout is expected here")
+  (word! layout)
+  (when (== expected-layouts 0) (after-layouts!)))
+
+(define (gpu-target! [format u32])
+  (item! (& expected-targets) "gpu: no target is expected here")
+  (word! format)
+  (when (== expected-targets 0) (after-targets!)))
+
+(define (gpu-vertex-buffer-layout! [stride u32] [step u32] [attributes u32])
+  (when (> expected-attributes 0) (host-trap "gpu: the attributes of the last vertex buffer are not complete"))
+  (item! (& expected-buffers) "gpu: no vertex buffer layout is expected here")
+  (words! (slice (array-of u32 stride step attributes)))
+  (set! expected-attributes attributes))
+
+(define (gpu-attribute! [location u32] [offset u32] [format u32])
+  (item! (& expected-attributes) "gpu: no attribute is expected here")
+  (words! (slice (array-of u32 location offset format))))
+
+(define (gpu-compute-pipeline! [shader u32] [entry string] [layouts u32]) -> u32
+  (complete!)
+  (let ([id (fresh! (& next-pipeline))])
+    (words! (slice (array-of u32 4 id shader)))
+    (text! entry)
+    (word! layouts)
+    (set! expected-layouts layouts)
+    (set! rendering #f)
+    id))
+
+(define (gpu-buffer! [size u32] [usage u32]) -> u32
+  (complete!)
+  (let ([id (fresh! (& next-buffer))])
+    (words! (slice (array-of u32 5 id size usage)))
+    id))
+
+(define (gpu-texture! [width u32] [height u32] [layers u32] [mips u32] [format u32] [usage u32]) -> u32
+  (complete!)
+  (let ([id (fresh! (& next-texture))])
+    (words! (slice (array-of u32 6 id width height layers mips format usage)))
+    id))
+
+(define (gpu-texture-file! [path string]) -> u32
+  (complete!)
+  (let ([id (fresh! (& next-texture))])
+    (words! (slice (array-of u32 7 id)))
+    (text! path)
+    id))
+
+(define (gpu-sampler! [filter u32] [address u32] [compare u32]) -> u32
+  (complete!)
+  (let ([id (fresh! (& next-sampler))])
+    (words! (slice (array-of u32 8 id filter address compare)))
+    id))
+
+(define (gpu-layout! [n u32]) -> u32
+  (complete!)
+  (let ([id (fresh! (& next-layout))])
+    (words! (slice (array-of u32 9 id n)))
+    (set! expected-entries n)
+    id))
+
+(define (gpu-layout-entry! [binding u32] [visibility u32] [kind u32])
+  (item! (& expected-entries) "gpu: no layout entry is expected here")
+  (words! (slice (array-of u32 binding visibility kind))))
+
+(define (gpu-bind-group! [layout u32] [pipeline u32] [group u32] [n u32]) -> u32
+  (complete!)
+  (let ([id (fresh! (& next-bind-group))])
+    (words! (slice (array-of u32 10 id layout pipeline group n)))
+    (set! expected-bindings n)
+    id))
+
+(define (gpu-bind-buffer! [binding u32] [buffer u32] [offset u32] [size u32])
+  (item! (& expected-bindings) "gpu: no binding is expected here")
+  (words! (slice (array-of u32 binding 1 buffer offset size))))
+
+(define (gpu-bind-sampler! [binding u32] [sampler u32])
+  (item! (& expected-bindings) "gpu: no binding is expected here")
+  (words! (slice (array-of u32 binding 2 sampler 0 0))))
+
+(define (gpu-bind-texture! [binding u32] [texture u32])
+  (item! (& expected-bindings) "gpu: no binding is expected here")
+  (words! (slice (array-of u32 binding 3 texture 0 0))))
+
+(define (gpu-destroy! [kind u32] [id u32])
+  (complete!)
+  (words! (slice (array-of u32 11 kind id))))
+
+;; ---- writing and reading ----
+
+(define (gpu-write-buffer! [buffer u32] [offset u32] [p (ptr void)] [n u32])
+  (complete!)
+  (words! (slice (array-of u32 12 buffer offset (cast u32 p) n))))
+
+(define (gpu-write-texture! [texture u32] [mip u32] [layer u32] [x u32] [y u32] [w u32] [h u32] [p (ptr void)] [n u32])
+  (complete!)
+  (words! (slice (array-of u32 13 texture mip layer x y w h (cast u32 p) n))))
+
+(define (gpu-read-texture! [texture u32] [mip u32] [layer u32] [x u32] [y u32] [w u32] [h u32])
+  (complete!)
+  (words! (slice (array-of u32 14 texture mip layer x y w h))))
+
+(define (gpu-read-buffer! [buffer u32] [offset u32] [n u32])
+  (complete!)
+  (words! (slice (array-of u32 15 buffer offset n))))
+
+;; ---- passes ----
+
+(define (gpu-render-pass! [targets u32] [depth-texture u32] [depth-mip u32] [depth-layer u32] [depth-load u32] [depth-clear f64])
+  (complete!)
+  (words! (slice (array-of u32 16 targets)))
+  (set! expected-pass-targets targets)
+  (set! pending-depth-texture depth-texture)
+  (set! pending-depth-mip depth-mip)
+  (set! pending-depth-layer depth-layer)
+  (set! pending-depth-load depth-load)
+  (set! pending-depth-clear depth-clear)
+  (when (== targets 0) (depth!)))
+
+(define pending-depth-texture u32 0)
+(define pending-depth-mip u32 0)
+(define pending-depth-layer u32 0)
+(define pending-depth-load u32 0)
+(define pending-depth-clear f64 0.0)
+
+(define (depth!)
+  (words! (slice (array-of u32 pending-depth-texture pending-depth-mip pending-depth-layer pending-depth-load)))
+  (float! pending-depth-clear))
+
+(define (gpu-pass-target! [kind u32] [id u32] [mip u32] [layer u32] [load u32] [r f64] [g f64] [b f64] [a f64])
+  (item! (& expected-pass-targets) "gpu: no pass target is expected here")
+  (words! (slice (array-of u32 kind id mip layer load)))
+  (float! r)
+  (float! g)
+  (float! b)
+  (float! a)
+  (when (== expected-pass-targets 0) (depth!)))
+
+(define (gpu-compute-pass!)
+  (complete!)
+  (word! 17))
+
+(define (gpu-end-pass!)
+  (complete!)
+  (word! 18))
+
+(define (gpu-pipeline! [pipeline u32])
+  (complete!)
+  (words! (slice (array-of u32 19 pipeline))))
+
+(define (gpu-bind-group-set! [group u32] [bind-group u32] [n u32])
+  (complete!)
+  (words! (slice (array-of u32 20 group bind-group n)))
+  (set! expected-offsets n))
+
+(define (gpu-offset! [offset u32])
+  (item! (& expected-offsets) "gpu: no offset is expected here")
+  (word! offset))
+
+(define (gpu-vertex-buffer! [slot u32] [buffer u32] [offset u32])
+  (complete!)
+  (words! (slice (array-of u32 21 slot buffer offset))))
+
+(define (gpu-index-buffer! [buffer u32] [format u32] [offset u32])
+  (complete!)
+  (words! (slice (array-of u32 22 buffer format offset))))
+
+(define (gpu-draw! [vertices u32] [instances u32] [first-vertex u32] [first-instance u32])
+  (complete!)
+  (words! (slice (array-of u32 23 vertices instances first-vertex first-instance))))
+
+(define (gpu-draw-indexed! [indexes u32] [instances u32] [first-index u32] [base-vertex u32] [first-instance u32])
+  (complete!)
+  (words! (slice (array-of u32 24 indexes instances first-index base-vertex first-instance))))
+
+(define (gpu-dispatch! [x u32] [y u32] [z u32])
+  (complete!)
+  (words! (slice (array-of u32 25 x y z))))
+
+(define (gpu-viewport! [x f64] [y f64] [w f64] [h f64])
+  (complete!)
+  (word! 26)
+  (float! x)
+  (float! y)
+  (float! w)
+  (float! h))
+
+(define (gpu-scissor! [x u32] [y u32] [w u32] [h u32])
+  (complete!)
+  (words! (slice (array-of u32 27 x y w h))))