substrate-lang 0.10.0 → 0.10.2

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))))