├── .gitignore
├── README.md
├── bml
    ├── Cargo.lock
    ├── Cargo.toml
    ├── LICENSE
    ├── README.md
    ├── TODO.md
    ├── examples
    │   ├── checkerboard.buf
    │   ├── circle.bml
    │   ├── closing_circle.bml
    │   ├── fractal_noise.bml
    │   ├── img
    │   │   ├── checkerboard.png
    │   │   ├── circle.png
    │   │   ├── closing_circle_rocket.gif
    │   │   ├── fractal_noise.png
    │   │   ├── invert_rocket.png
    │   │   ├── mandelbrot.png
    │   │   ├── projected_julia.gif
    │   │   ├── quadrant_rocket.png
    │   │   ├── rocket.png
    │   │   ├── sample_rocket.png
    │   │   └── sawtooth.gif
    │   ├── invert.bml
    │   ├── mandelbrot.bml
    │   ├── mod_sawtooth.bml
    │   ├── projected_julia.bml
    │   ├── quadrant.bml
    │   └── sample.bml
    └── src
    │   ├── ast.rs
    │   ├── lib.rs
    │   ├── logger.rs
    │   ├── macro.rs
    │   ├── main.rs
    │   ├── parser.rs
    │   ├── preprocessor.rs
    │   ├── scanner.rs
    │   ├── token.rs
    │   └── token_type.rs
└── slackbot
    ├── package-lock.json
    ├── package.json
    ├── src
        ├── Domains.ts
        └── app.ts
    └── tsconfig.json


/.gitignore:
--------------------------------------------------------------------------------
 1 | node_modules
 2 | log.txt
 3 | tmp
 4 | build
 5 | **/target
 6 | 
 7 | # vi swapfiles
 8 | *.swp
 9 | *.swo
10 | 
11 | # any scattered pngs/gifs that aren't examples
12 | *.png
13 | !bml/examples/img/*.png
14 | 
15 | *.gif
16 | !bml/examples/img/*.gif
17 | 
18 | # critical json files
19 | auth.json
20 | domains.json
21 | 
22 | .DS_Store
23 | .vscode


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # bml
2 | 
3 | BML, or "Buffer Manipulation Language", is an interpreter for programatically processing or generating images/gifs using a simple, easy-to-learn C-like language.
4 | 
5 | ## Repo structure
6 | 
7 | This repository is a monorepo for BML and the BML runtime itself (in `/bml`) and a Slack Bot (`/slackbot`) which interfaces with BML.
8 | 
9 | For trying out BML, usage is documented in `/bml/README.md`.


--------------------------------------------------------------------------------
/bml/Cargo.lock:
--------------------------------------------------------------------------------
  1 | # This file is automatically @generated by Cargo.
  2 | # It is not intended for manual editing.
  3 | version = 3
  4 | 
  5 | [[package]]
  6 | name = "adler"
  7 | version = "1.0.2"
  8 | source = "registry+https://github.com/rust-lang/crates.io-index"
  9 | checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
 10 | 
 11 | [[package]]
 12 | name = "adler32"
 13 | version = "1.2.0"
 14 | source = "registry+https://github.com/rust-lang/crates.io-index"
 15 | checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234"
 16 | 
 17 | [[package]]
 18 | name = "ahash"
 19 | version = "0.7.6"
 20 | source = "registry+https://github.com/rust-lang/crates.io-index"
 21 | checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
 22 | dependencies = [
 23 |  "getrandom",
 24 |  "once_cell",
 25 |  "version_check",
 26 | ]
 27 | 
 28 | [[package]]
 29 | name = "atty"
 30 | version = "0.2.14"
 31 | source = "registry+https://github.com/rust-lang/crates.io-index"
 32 | checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
 33 | dependencies = [
 34 |  "hermit-abi",
 35 |  "libc",
 36 |  "winapi",
 37 | ]
 38 | 
 39 | [[package]]
 40 | name = "autocfg"
 41 | version = "1.0.1"
 42 | source = "registry+https://github.com/rust-lang/crates.io-index"
 43 | checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
 44 | 
 45 | [[package]]
 46 | name = "bitflags"
 47 | version = "1.3.2"
 48 | source = "registry+https://github.com/rust-lang/crates.io-index"
 49 | checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 50 | 
 51 | [[package]]
 52 | name = "bml"
 53 | version = "1.0.1"
 54 | dependencies = [
 55 |  "colored",
 56 |  "image",
 57 |  "lasso",
 58 |  "rayon",
 59 | ]
 60 | 
 61 | [[package]]
 62 | name = "bytemuck"
 63 | version = "1.7.3"
 64 | source = "registry+https://github.com/rust-lang/crates.io-index"
 65 | checksum = "439989e6b8c38d1b6570a384ef1e49c8848128f5a97f3914baef02920842712f"
 66 | 
 67 | [[package]]
 68 | name = "byteorder"
 69 | version = "1.4.3"
 70 | source = "registry+https://github.com/rust-lang/crates.io-index"
 71 | checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 72 | 
 73 | [[package]]
 74 | name = "cfg-if"
 75 | version = "1.0.0"
 76 | source = "registry+https://github.com/rust-lang/crates.io-index"
 77 | checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 78 | 
 79 | [[package]]
 80 | name = "color_quant"
 81 | version = "1.1.0"
 82 | source = "registry+https://github.com/rust-lang/crates.io-index"
 83 | checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
 84 | 
 85 | [[package]]
 86 | name = "colored"
 87 | version = "2.0.0"
 88 | source = "registry+https://github.com/rust-lang/crates.io-index"
 89 | checksum = "b3616f750b84d8f0de8a58bda93e08e2a81ad3f523089b05f1dffecab48c6cbd"
 90 | dependencies = [
 91 |  "atty",
 92 |  "lazy_static",
 93 |  "winapi",
 94 | ]
 95 | 
 96 | [[package]]
 97 | name = "crc32fast"
 98 | version = "1.3.0"
 99 | source = "registry+https://github.com/rust-lang/crates.io-index"
100 | checksum = "738c290dfaea84fc1ca15ad9c168d083b05a714e1efddd8edaab678dc28d2836"
101 | dependencies = [
102 |  "cfg-if",
103 | ]
104 | 
105 | [[package]]
106 | name = "crossbeam-channel"
107 | version = "0.5.1"
108 | source = "registry+https://github.com/rust-lang/crates.io-index"
109 | checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4"
110 | dependencies = [
111 |  "cfg-if",
112 |  "crossbeam-utils",
113 | ]
114 | 
115 | [[package]]
116 | name = "crossbeam-deque"
117 | version = "0.8.1"
118 | source = "registry+https://github.com/rust-lang/crates.io-index"
119 | checksum = "6455c0ca19f0d2fbf751b908d5c55c1f5cbc65e03c4225427254b46890bdde1e"
120 | dependencies = [
121 |  "cfg-if",
122 |  "crossbeam-epoch",
123 |  "crossbeam-utils",
124 | ]
125 | 
126 | [[package]]
127 | name = "crossbeam-epoch"
128 | version = "0.9.5"
129 | source = "registry+https://github.com/rust-lang/crates.io-index"
130 | checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd"
131 | dependencies = [
132 |  "cfg-if",
133 |  "crossbeam-utils",
134 |  "lazy_static",
135 |  "memoffset",
136 |  "scopeguard",
137 | ]
138 | 
139 | [[package]]
140 | name = "crossbeam-utils"
141 | version = "0.8.5"
142 | source = "registry+https://github.com/rust-lang/crates.io-index"
143 | checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db"
144 | dependencies = [
145 |  "cfg-if",
146 |  "lazy_static",
147 | ]
148 | 
149 | [[package]]
150 | name = "deflate"
151 | version = "0.8.6"
152 | source = "registry+https://github.com/rust-lang/crates.io-index"
153 | checksum = "73770f8e1fe7d64df17ca66ad28994a0a623ea497fa69486e14984e715c5d174"
154 | dependencies = [
155 |  "adler32",
156 |  "byteorder",
157 | ]
158 | 
159 | [[package]]
160 | name = "either"
161 | version = "1.6.1"
162 | source = "registry+https://github.com/rust-lang/crates.io-index"
163 | checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
164 | 
165 | [[package]]
166 | name = "getrandom"
167 | version = "0.2.3"
168 | source = "registry+https://github.com/rust-lang/crates.io-index"
169 | checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
170 | dependencies = [
171 |  "cfg-if",
172 |  "libc",
173 |  "wasi",
174 | ]
175 | 
176 | [[package]]
177 | name = "gif"
178 | version = "0.11.3"
179 | source = "registry+https://github.com/rust-lang/crates.io-index"
180 | checksum = "c3a7187e78088aead22ceedeee99779455b23fc231fe13ec443f99bb71694e5b"
181 | dependencies = [
182 |  "color_quant",
183 |  "weezl",
184 | ]
185 | 
186 | [[package]]
187 | name = "hashbrown"
188 | version = "0.11.2"
189 | source = "registry+https://github.com/rust-lang/crates.io-index"
190 | checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
191 | dependencies = [
192 |  "ahash",
193 | ]
194 | 
195 | [[package]]
196 | name = "hermit-abi"
197 | version = "0.1.19"
198 | source = "registry+https://github.com/rust-lang/crates.io-index"
199 | checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
200 | dependencies = [
201 |  "libc",
202 | ]
203 | 
204 | [[package]]
205 | name = "image"
206 | version = "0.23.14"
207 | source = "registry+https://github.com/rust-lang/crates.io-index"
208 | checksum = "24ffcb7e7244a9bf19d35bf2883b9c080c4ced3c07a9895572178cdb8f13f6a1"
209 | dependencies = [
210 |  "bytemuck",
211 |  "byteorder",
212 |  "color_quant",
213 |  "gif",
214 |  "jpeg-decoder",
215 |  "num-iter",
216 |  "num-rational",
217 |  "num-traits",
218 |  "png",
219 |  "scoped_threadpool",
220 |  "tiff",
221 | ]
222 | 
223 | [[package]]
224 | name = "jpeg-decoder"
225 | version = "0.1.22"
226 | source = "registry+https://github.com/rust-lang/crates.io-index"
227 | checksum = "229d53d58899083193af11e15917b5640cd40b29ff475a1fe4ef725deb02d0f2"
228 | dependencies = [
229 |  "rayon",
230 | ]
231 | 
232 | [[package]]
233 | name = "lasso"
234 | version = "0.6.0"
235 | source = "registry+https://github.com/rust-lang/crates.io-index"
236 | checksum = "aeb7b21a526375c5ca55f1a6dfd4e1fad9fa4edd750f530252a718a44b2608f0"
237 | dependencies = [
238 |  "hashbrown",
239 | ]
240 | 
241 | [[package]]
242 | name = "lazy_static"
243 | version = "1.4.0"
244 | source = "registry+https://github.com/rust-lang/crates.io-index"
245 | checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
246 | 
247 | [[package]]
248 | name = "libc"
249 | version = "0.2.112"
250 | source = "registry+https://github.com/rust-lang/crates.io-index"
251 | checksum = "1b03d17f364a3a042d5e5d46b053bbbf82c92c9430c592dd4c064dc6ee997125"
252 | 
253 | [[package]]
254 | name = "memoffset"
255 | version = "0.6.5"
256 | source = "registry+https://github.com/rust-lang/crates.io-index"
257 | checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
258 | dependencies = [
259 |  "autocfg",
260 | ]
261 | 
262 | [[package]]
263 | name = "miniz_oxide"
264 | version = "0.3.7"
265 | source = "registry+https://github.com/rust-lang/crates.io-index"
266 | checksum = "791daaae1ed6889560f8c4359194f56648355540573244a5448a83ba1ecc7435"
267 | dependencies = [
268 |  "adler32",
269 | ]
270 | 
271 | [[package]]
272 | name = "miniz_oxide"
273 | version = "0.4.4"
274 | source = "registry+https://github.com/rust-lang/crates.io-index"
275 | checksum = "a92518e98c078586bc6c934028adcca4c92a53d6a958196de835170a01d84e4b"
276 | dependencies = [
277 |  "adler",
278 |  "autocfg",
279 | ]
280 | 
281 | [[package]]
282 | name = "num-integer"
283 | version = "0.1.44"
284 | source = "registry+https://github.com/rust-lang/crates.io-index"
285 | checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
286 | dependencies = [
287 |  "autocfg",
288 |  "num-traits",
289 | ]
290 | 
291 | [[package]]
292 | name = "num-iter"
293 | version = "0.1.42"
294 | source = "registry+https://github.com/rust-lang/crates.io-index"
295 | checksum = "b2021c8337a54d21aca0d59a92577a029af9431cb59b909b03252b9c164fad59"
296 | dependencies = [
297 |  "autocfg",
298 |  "num-integer",
299 |  "num-traits",
300 | ]
301 | 
302 | [[package]]
303 | name = "num-rational"
304 | version = "0.3.2"
305 | source = "registry+https://github.com/rust-lang/crates.io-index"
306 | checksum = "12ac428b1cb17fce6f731001d307d351ec70a6d202fc2e60f7d4c5e42d8f4f07"
307 | dependencies = [
308 |  "autocfg",
309 |  "num-integer",
310 |  "num-traits",
311 | ]
312 | 
313 | [[package]]
314 | name = "num-traits"
315 | version = "0.2.14"
316 | source = "registry+https://github.com/rust-lang/crates.io-index"
317 | checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
318 | dependencies = [
319 |  "autocfg",
320 | ]
321 | 
322 | [[package]]
323 | name = "num_cpus"
324 | version = "1.13.0"
325 | source = "registry+https://github.com/rust-lang/crates.io-index"
326 | checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
327 | dependencies = [
328 |  "hermit-abi",
329 |  "libc",
330 | ]
331 | 
332 | [[package]]
333 | name = "once_cell"
334 | version = "1.9.0"
335 | source = "registry+https://github.com/rust-lang/crates.io-index"
336 | checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5"
337 | 
338 | [[package]]
339 | name = "png"
340 | version = "0.16.8"
341 | source = "registry+https://github.com/rust-lang/crates.io-index"
342 | checksum = "3c3287920cb847dee3de33d301c463fba14dda99db24214ddf93f83d3021f4c6"
343 | dependencies = [
344 |  "bitflags",
345 |  "crc32fast",
346 |  "deflate",
347 |  "miniz_oxide 0.3.7",
348 | ]
349 | 
350 | [[package]]
351 | name = "rayon"
352 | version = "1.5.1"
353 | source = "registry+https://github.com/rust-lang/crates.io-index"
354 | checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90"
355 | dependencies = [
356 |  "autocfg",
357 |  "crossbeam-deque",
358 |  "either",
359 |  "rayon-core",
360 | ]
361 | 
362 | [[package]]
363 | name = "rayon-core"
364 | version = "1.9.1"
365 | source = "registry+https://github.com/rust-lang/crates.io-index"
366 | checksum = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e"
367 | dependencies = [
368 |  "crossbeam-channel",
369 |  "crossbeam-deque",
370 |  "crossbeam-utils",
371 |  "lazy_static",
372 |  "num_cpus",
373 | ]
374 | 
375 | [[package]]
376 | name = "scoped_threadpool"
377 | version = "0.1.9"
378 | source = "registry+https://github.com/rust-lang/crates.io-index"
379 | checksum = "1d51f5df5af43ab3f1360b429fa5e0152ac5ce8c0bd6485cae490332e96846a8"
380 | 
381 | [[package]]
382 | name = "scopeguard"
383 | version = "1.1.0"
384 | source = "registry+https://github.com/rust-lang/crates.io-index"
385 | checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
386 | 
387 | [[package]]
388 | name = "tiff"
389 | version = "0.6.1"
390 | source = "registry+https://github.com/rust-lang/crates.io-index"
391 | checksum = "9a53f4706d65497df0c4349241deddf35f84cee19c87ed86ea8ca590f4464437"
392 | dependencies = [
393 |  "jpeg-decoder",
394 |  "miniz_oxide 0.4.4",
395 |  "weezl",
396 | ]
397 | 
398 | [[package]]
399 | name = "version_check"
400 | version = "0.9.3"
401 | source = "registry+https://github.com/rust-lang/crates.io-index"
402 | checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
403 | 
404 | [[package]]
405 | name = "wasi"
406 | version = "0.10.2+wasi-snapshot-preview1"
407 | source = "registry+https://github.com/rust-lang/crates.io-index"
408 | checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
409 | 
410 | [[package]]
411 | name = "weezl"
412 | version = "0.1.5"
413 | source = "registry+https://github.com/rust-lang/crates.io-index"
414 | checksum = "d8b77fdfd5a253be4ab714e4ffa3c49caf146b4de743e97510c0656cf90f1e8e"
415 | 
416 | [[package]]
417 | name = "winapi"
418 | version = "0.3.9"
419 | source = "registry+https://github.com/rust-lang/crates.io-index"
420 | checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
421 | dependencies = [
422 |  "winapi-i686-pc-windows-gnu",
423 |  "winapi-x86_64-pc-windows-gnu",
424 | ]
425 | 
426 | [[package]]
427 | name = "winapi-i686-pc-windows-gnu"
428 | version = "0.4.0"
429 | source = "registry+https://github.com/rust-lang/crates.io-index"
430 | checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
431 | 
432 | [[package]]
433 | name = "winapi-x86_64-pc-windows-gnu"
434 | version = "0.4.0"
435 | source = "registry+https://github.com/rust-lang/crates.io-index"
436 | checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
437 | 


--------------------------------------------------------------------------------
/bml/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "bml"
 3 | version = "1.0.1"
 4 | edition = "2021"
 5 | 
 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 7 | 
 8 | [dependencies]
 9 | image = "0.23.14"
10 | lasso = "0.6.0"
11 | colored = "2.0.0"
12 | rayon = "1.5"


--------------------------------------------------------------------------------
/bml/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Prof. Sucrose
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/bml/README.md:
--------------------------------------------------------------------------------
  1 | # bml
  2 | 
  3 | BML, or "Buffer Manipulation Language," is a preprocessor and runtime for basic but programmatic image manipulation.
  4 | 
  5 | ## Building
  6 | 
  7 | BML uses Rust, and can be built or run using `cargo`, which can be installed using [rustup](https://rustup.rs/).
  8 | 
  9 | For *nix users, you can download the `/bml` subdir with:
 10 | ```bash
 11 | git clone https://github.com/profsucrose/bml _bml && mv _bml/bml . && rm -rf _bml
 12 | ```
 13 | 
 14 | And then to build, run
 15 | 
 16 | ```bash
 17 | cargo run --release <options>
 18 | ```
 19 | 
 20 | while in the directory, or use `cargo build --release` and run the built binary in `./target/release/bml`.
 21 | 
 22 | Although building in release mode is not necessary, it is highly recommended for improved performance.
 23 | 
 24 | ## Usage
 25 | 
 26 | When running BML, there are three primary options:
 27 | 
 28 | ```./bml eval <path/to/script.buf>```
 29 | 
 30 | Which will simply evaluate the given script and print the `return`-ed result.
 31 | 
 32 | ```./bml process <path/to/script.buf> <path/to/image.png> <frames> [output_path]```
 33 | 
 34 | Which will process a given image through a given script. If `<frames>` is specified and greater than 1, a gif will be generated instead of a static image. The output will be written to an automatically determined path, or alternatively write to `output_path` instead if valid.
 35 | 
 36 | ```bml new <script> <width> <height> <frames> <output_path>```
 37 | 
 38 | Which, instead of processing an existing image like `bml process`, `new` will create a new image from scratch using a given script, where `frag` will be set to `[0, 0, 0, 0]` for every pixel. Like `process`, if `<frames>` is greater than 1 the output will be a GIF instead of a PNG.
 39 | 
 40 | ## Intro
 41 | 
 42 | BML itself is a fairly rudimentary C-like language loosely inspired by the likes of shading languages such as GLSL. The premise is that you take in any arbitrary image, and then for each pixel/coordinate output a new one, resulting in a brand new image (or animation!).
 43 | 
 44 | As an example, let's take this initial image:
 45 | 
 46 | <img src="examples/img/rocket.png" width=250 height=250 alt="A starting image" />
 47 | 
 48 | And run it through this script, which will invert every pixel in an image:
 49 | 
 50 | ```invert.bml
 51 | # invert each pixel
 52 | 
 53 | return [1 - frag.r, 1 - frag.g, 1 - frag.b, 1]
 54 | ```
 55 | 
 56 | After running `bml process`, we get this:
 57 | 
 58 | <img src="examples/img/invert_rocket.png" width=250 height=250 alt="Starting image after running `invert.bml`" />
 59 | 
 60 | For each pixel (or fragment/`frag`, represented as an RGBA vec4 from 0-1) the script will subtract each component from 1, and then keep the original opacity of the pixel (note that the lack of a background is preserved).
 61 | 
 62 | If you're familiar with the likes of GLSL or Shadertoy, this should look pretty familiar.However, BML offers the advantage of having a good bit less boilerplate/setup and is specifically oriented around processing images.
 63 | 
 64 | Similarly, BML also has support for easily generating gifs:
 65 | 
 66 | ```closing_circle.bml
 67 | # - cartoon-style closing circle - #
 68 | 
 69 | # get normalized x, y coordinates from 0-1
 70 | uv = coord / resolution
 71 | 
 72 | # get distance to center
 73 | distance = dist(uv, [0.5, 0.5])
 74 | 
 75 | # radius starts at 1 and shrinks to 0 as frame/frame_count goes from 0 to 1
 76 | radius = 1 - frame / (frame_count - 1)
 77 | 
 78 | # if distance is less than the radius, pixel is inside circle
 79 | circle = distance < radius               
 80 | 
 81 | return frag if circle else [0, 0, 0, 1]  # return original pixel if inside circle, else black
 82 | ```
 83 | 
 84 | Which, when running `bml process` with the image from earlier, outputs this:
 85 | 
 86 | <img src="examples/img/closing_circle_rocket.gif" width=300 height=300>
 87 | 
 88 | Instead of only processing a single frame, BML in this case (when run with multiple frames specified, e.g. 20 in the above example) will generate some arbitrary number of frames by duplicating the original image and running a script on each one. 
 89 | 
 90 | Then, in the script itself, we can see which frame we are on by getting the `frame` variable, which is the index of the current frame (0-indexed, so going from 0 to 19 in the example) and comparing it to `frame_count`, which is the total number of frames (e.g. 20).
 91 | 
 92 | In summary BML is pretty much a simplified, dynamically-typed GLSL specifically oriented around easily and concisely processing images and gifs.
 93 | 
 94 | ## Language
 95 | 
 96 | Most of the syntax should be familiar to anyone used to a C-family language/GLSL, but there are some idiosyncrasies specific to BML.
 97 | 
 98 | ### Types
 99 | 
100 | BML has three basic types/primitives:
101 | 
102 | * **Scalars** or floats
103 | 
104 | Every number in GLSL is represented as an IEEE 754 32-bit float, or an `f32` in Rust. Unlike GLSL, since every number is a float, `1` and `1.0` are both floats, and can be used for any operations, expressions or statements that expect floats, e.g. vectors or matrices. Note, however, that GLSL syntax like `.5` or `5.` is unsupported and will result in a `ParseError`.
105 | 
106 | * **Vectors**: BML has support for 2x1 vectors, 3x1 vectors, and 4x1 vectors. (Or called "vec2", "vec3" and "vec4" respectively)
107 | 
108 | Unlike GLSL, the syntax for vectors in BML are more like arrays in Rust than function calls. You can initialize a vec2, a vec3, or a vec4 with `[1, 2]`, `[1, 2, 3]` or `[1, 2, 3, 4]` respectively. You can also concisely define a vector with a repeated value by putting the value, a `;`, and then the length: e.g., `[1, 1, 1, 1]` becomes `[1; 4]`. This works for any arbitrary expression as well, so `[1; 4]` is equal to `[0.5 * 2 * 7 / 7; 4]`, or `[x; 4]` if `x=1`.
109 | 
110 | A vector component can be acccessed with the `.` syntax `.x`, `.y`, `.z`, `.w`. So `[1, 2].x` becomes `1`. You can also use the aliases `.rgba` when using colors, so `[0.5, 0.1, 0.9].r` is `0.5`.
111 | 
112 |  You can also "swizzle" vectors in any order to get any new vector or float. For example, `[1, 2, 3, 4].wyzx` returns `[4, 2, 3, 1]`, or `[0.1, 0.2, 0.3].rg` becomes `[0.1, 0.2]`.
113 | 
114 |  * **Matrices**: BML also suports built-in 2x2, 3x3 and 4x4 matrix primitives.
115 | 
116 | A matrix is treated as just a (column-major) list of vectors/columns, hence you can define a matrix by specifying each column using built-in functions. `mat2([1, 0], [0, 1])` becomes 
117 | 
118 | ```
119 | [ 1, 0 ]
120 | [ 0, 1 ]
121 | ```
122 | 
123 | or `mat3([1, 2, 3], [4, 5, 6], [7, 8, 9])` becomes
124 | 
125 | ```
126 | [ 1, 4, 7 ]
127 | [ 2, 5, 8 ]
128 | [ 3, 6, 9 ]
129 | ```
130 | 
131 | Note again that matrices are _column-major_ (which could result in some bugs!) so the first argument to `mat2`, `mat3` or `mat4` is the _first column_ and not the first row.
132 | 
133 | You can index a matrix to get a column with `<matrix>[column]`. So `mat2([1, 0], [0, 1])[0] == [1, 0]`.
134 | 
135 | You can multiply matrices with vectors to represent transformations. So for instance, to scale a vector `point=[1, 2, 3, 1]` which represents some 3d point, you could scale it by doing `scale(5) * point`, or rotate it with `rotate_x(3.14159 / 2) * point`.
136 | 
137 | ### Variables
138 | 
139 | Variable declarations are just `<name> = <value>`, where no variable is statically-typed and can be redefined at any time. If a variable is used before it is defined, BML will throw an error:
140 | 
141 | ```
142 | x = 10 * 2 + 1
143 | x = [1, 2]
144 | y = [1, 2].yz
145 | x = y + y
146 | 
147 | x = z # will throw an error
148 | ```
149 | 
150 | ### Uniforms
151 | 
152 | For getting the current pixel, coordinate, or gif frame, BML loads some variables into the script namespace:
153 | 
154 | `vec2 coord`: stores the current pixel coordinate as [x, y]. Note that this is not normalized, so for instance if processign a 100 by 100 pixel image, the `coord` variable would be [0, 0] at the bottom-left and [100, 100] at the top-right.
155 | 
156 | `vec2 resolution`: stores the width and height of the image as [width, height]
157 | 
158 | `vec2 frag`: stores current pixel color as [r, g, b, a] where each color is 0-1.
159 | 
160 | `float frame`: stores current frame if processing a gif. Starts at 0 and ends at `frame_count - 1`
161 | 
162 | `float frame_count`: stores the specified number of frames if processing a gif.
163 | 
164 | ### Control Flow
165 | 
166 | For control flow, `BML` has an `if`, `repeat` and `while` statements.
167 | 
168 | An `if` statement will return the first part if the condition equals 1.0, and return the second part if otherwise:
169 | 
170 | ```
171 | x = 5 if 1 else 1 # x is now equal to 5
172 | y = 2 if 0.5 else 0.25 # y is now 0.25
173 | 
174 | # == and != will give 1.0 if true, 0.0 if otherwise
175 | # z becomes 1
176 | z = 1 if 5 == 5 else 0.5
177 | ```
178 | 
179 | BML also has block expressions, which can be used for statements, `give`-ing values or both:
180 | 
181 | ```
182 | # x is now 5.5
183 | x = {
184 |     y = 5
185 |     give y + 0.5 # `give` will exit the block and give it a specified value
186 | }
187 | 
188 | 
189 | z = 8
190 | 
191 | # the remainder of z / 2 is 0, so
192 | # z will decrement 
193 | # and y will be set to 0.5
194 | y = {
195 |     z = z - 1 # blocks can both mutate state and be used as expressions
196 |     give 0.5
197 | } if mod(z, 2) == 0 else {
198 |     give 0.2
199 | }
200 | ```
201 | 
202 | The `repeat` statement will just execute a block a specified number of times:
203 | 
204 | ```
205 | i = 0
206 | 
207 | repeat 100 {
208 |     i = i + 1
209 | }
210 | 
211 | # i is now 100
212 | ```
213 | 
214 | However the number of times you can repeat `repeat` something is determined at compile-time -- so it must be a literal or a macro.
215 | 
216 | ```
217 | macro iter() 5
218 | 
219 | # this is run
220 | repeat iter() { }
221 | 
222 | x = 5 + 2 * coord.x
223 | 
224 | # this will not
225 | repeat x { }
226 | ```
227 | 
228 | Similarly, with a `while` statement, you can repeat a block a set number of times, but if a given condition becomes false before then BML will exit the loop early.
229 | 
230 | ```
231 | i = 0
232 | 
233 | while 1 < 50, 100 {
234 |     i = i + 1
235 | }
236 | 
237 | # i is now 50
238 | ```
239 | 
240 | Like GLSL, since BML only has finite loops that can't be arbitrarily or infinitely long, and only has macros but no runtime functions/recursion, BML is technically not turing-complete and any program must always finish at _some_ point.
241 | 
242 | ### Macros
243 | 
244 | Instead of functions, for basic code reuse/organization BML offers C-like macros:
245 | 
246 | ```
247 | macro add_one(x) x + 1
248 | 
249 | y = add_one(10)
250 | z = add_one(5 + {
251 |     give add_one(2) + add_one(y)
252 | })
253 | 
254 | # expands to
255 | y = 10 + 1
256 | z = 5 + {
257 |     give 2 + 1 + y + 1
258 | } + 1
259 | ```
260 | 
261 | Whenever a macro is invoked, all identifiers in the expansion specified in the parameters in the macro declaration will be replaced respectively with the called arguments. 
262 | 
263 | If the macro doesn't start with a block, the definition will only extend to the end of the line. However, if the macro does start with a block, every invocation will be replaced with the whole block instead of a single line:
264 | 
265 | ```
266 | macro sum(vec3) {
267 |     give vec3.x + vec3.y + vec3.z
268 | }
269 | 
270 | macro add_and_multiply(x, y, z) {
271 |     added = x + y + z
272 |     multed = [x, y, z] * [added; 3]
273 |     give sum(multed)
274 | }
275 | 
276 | x = add_and_multiply(1, 2, 3)
277 | 
278 | # expands to
279 | x = {
280 |     added = 1 + 2 + 3
281 |     multed = [1, 2, 3] * [added; 3]
282 |     give {
283 |         multed.x + multed.y + multed.z
284 |     }
285 | }
286 | ```
287 | 
288 | ### Built-In Functions
289 | 
290 | For certain functionality like square roots or exponents, BML supports built-in functions baked into the interpreter that are treated like macro calls.
291 | 
292 | ```
293 | # x now equals 3
294 | x = sqrt(9)
295 | 
296 | # 2^8.5
297 | y = pow(2, 8.5)
298 | 
299 | # get distance from normalized coordinates to center
300 | uv = coord / resolution
301 | distance = dist(uv, [0.5, 0.5])
302 | 
303 | # clamp value between 2 and 5
304 | large_value = 1000
305 | clamped = clamp(large_value, 2, 5) # becomes 5
306 | ```
307 | 
308 | Most of the standard shading functions one would expect in GLSL are in BML:
309 | 
310 | * `dist(p0, p1)`: gets the distance between two floats or vectors
311 | * `radians(degrees)`: converts a float or vector in degrees to be in radians
312 | * `degrees(radians)`: converts a float or vector in radians to be in degrees
313 | * `sin(angle)`: takes sine component-wise of float or vector
314 | * `cos(angle)`: cosine of angle
315 | * `tan(angle)`: tangent of angle
316 | * `asin(x)`: arcsin of x
317 | * `acos(x)`: arccos of x
318 | * `atan(x)`: arctangent of x
319 | * `pow(base, exponent)`: raises base to the power of exponent
320 | * `exp(x)`: exponential function, or e^x
321 | * `log(x)`: natural log of x
322 | * `sqrt(x)`: square root of x
323 | * `invsqrt(x)`: inverse square root of x
324 | * `abs(x)`: absolute value of x
325 | * `sign(x)`: gets sign of x -- for each component, return 1 if positive, 0 if 0, or -1 if negative
326 | * `floor(x)`: gets the floor of (rounds down) x
327 | * `ceil(x)`: gets the ceiling of (rounds up) x
328 | * `fract(x)`: gets the fractional part of x
329 | * `mod(x, y)`: gets the modulo of x and y
330 | * `min(x, y)`: gets the minimum of x and y
331 | * `max(x, y)`: gets the maximum of x and y
332 | * `clamp(x, min, max)`: "clamps" x between min and max -- returns min if x <= min, max if x >= max, or x if otherwise
333 | * `mix(x, y, a)`: linearly interpolates or "mixes" between x and y according to a (a=0 would return x, a=0.5 would return the value between x and y, and a=1 would be y). If x, y and a are all vectors (assuming they're all the same length) then perform mix component-wise. If x and y are vectors and a is a float, then perform mix component-wise where a is the same float for each component.
334 | * `step(edge, x)`: returns 0 if x is smaller than edge, otherwise returns 1. Will do this component-wise if edge and x are floats/vectors of the same length, or will do it component-wise for x if edge is a scalar and x is a vector.
335 | * `length(x)`: returns the length (or magnitude) of x if x is a vector
336 | * `dot(x, y)`: takes the dot product of x and y
337 | * `cross(x, y)`: takes the cross product of x and y
338 | * `norm(x)`: normalizes x if x is a vector
339 | * `mat2(col1, col2)`: creates a new 2x2 matrix
340 | * `mat3(col1, col2, col3)`: creates a new 3x3 matrix
341 | * `mat4(col1, col2, col3, col4)`: creates a new 4x4 matrix
342 | * `rotate_x(radians)`: returns a 4x4 transformation matrix that rotates a specified number of radians about the x-axis
343 | * `rotate_y(radians)`: returns a 4x4 transformation matrix that rotates about the y-axis
344 | * `rotate_z(radians)`: returns a 4x4 transformation matrix that rotates about the z-axis
345 | * `rotate(yaw, pitch, roll)`: returns a 4x4 transformation matrix that rotataes about the x, y and z axes according to yaw, pitch and roll (all in radians) respectively
346 | * `scale(x)`: returns a 4x4 transformation matrix that scales a point x times
347 | * `translate(x, y, z)`: returns a 4x4 transformation matrix that translates accordingly in the x, y, and z dimensions
348 | * `ortho(near, far, left, right, top, bottom)`: returns a 4x4 transformation matrix for orthographic projection
349 | * `lookat(from, to)`: returns a 4x4 transformation `lookat` matrix
350 | * `perspective(fov, near, far)`: returns a 4x4 perspective projection matrix
351 | 
352 | ### Sample()
353 | 
354 | A special function unique to BML is `sample(coordinates)`. Which will return the pixel in the original image (assuming that a pre-existing iamge is being processed) according to any arbitrary normalized x and y coordinates from 0-1. E.g., `sample([0, 0])` returns the pixel at the bottom-left of the image, and `sample([1, 1])` returns the pixel at the top-right. 
355 | 
356 | Although the `frag` variable already gives you the color of the current pixel, being able to arbitrarily sample from the image or around the current pixel can be useful for things such as certain distortions.
357 | 
358 | #### `return`-ing
359 | 
360 | A BML program consists of a series of statements which at some point must return a new RGBA color represented as a 4x1 vector `[R, G, B, A]`, where each component is from 0 to 1, using the `return` statement. Going back to the closing circle example:
361 | 
362 | ```
363 | # cartoon-style closing circle
364 | 
365 | uv = coord / resolution
366 | distance = dist(uv, [0.5, 0.5])
367 | circle = distance < 1 - frame / (frame_count - 1)
368 | return frag if circle else [0, 0, 0, 1]
369 | ```
370 | 
371 | How the script returns the new pixel color is through that final `return` statement. Note that this is short-circuiting:
372 | 
373 | ```
374 | # cartoon-style closing circle
375 | 
376 | uv = coord / resolution
377 | distance = dist(uv, [0.5, 0.5])
378 | circle = distance < 1 - frame / (frame_count - 1)
379 | 
380 | {
381 |     # if condition is true, then program would end here
382 |     return frag
383 | } if circle
384 | 
385 | # does not run if condition is true
386 | return [1; 4]
387 | ```
388 | 
389 | ## Examples
390 | 
391 | Some more example scripts can be seen in `examples` and the images rendered from them in `examples/img`.


--------------------------------------------------------------------------------
/bml/TODO.md:
--------------------------------------------------------------------------------
 1 | # TODO
 2 | 
 3 | * Matrices
 4 | * Fix nested blocks in macros
 5 | * Sc integration w/ bot
 6 | * Gif generation w/ bot
 7 | * add flags for blank image generation
 8 | 
 9 | 
10 | ## BML
11 |     * DONE: finish preprocessor (nested macros)
12 |     * DONE: test AST, hook up w/ image library
13 |     * DONE: Integrate lasso
14 |     * DONE: PARSER
15 |         - frag, coord, resolution, frame, max_frame
16 |     * Extra lang features:
17 |         - more built-in functions (GLSL)
18 |         - matrices
19 |         - repeat block
20 |     * Maybe: add pretty error reporting w/ codespan
21 |         - parser
22 |         - AST eval?
23 |     * TCP daemon/server for processing PNGs, JPGs & gifs?
24 |         - integrate bml w/ bot
25 | 
26 | ## WORKING: SlackBot
27 |     * take money for people to manipulate image
28 |         - needs own token
29 |     * /bot corrupt "script.bml"
30 |         - gets last posted image
31 |         - runs bml
32 |         - posts in channel 
33 |     * *bot listens for DMs*
34 |         - if receives script.bml, uploads script
35 |     * every min you get 5
36 |     * gifs
37 | 
38 | 
39 | 


--------------------------------------------------------------------------------
/bml/examples/checkerboard.buf:
--------------------------------------------------------------------------------
1 | # generate checkerboard
2 | 
3 | size = 40
4 | pos = floor([coord.x / size, coord.y / size])
5 | 
6 | return [1, 1, 1, 1] if mod(pos.x + mod(pos.y, 2), 2) == 1 else [0, 0, 0, 1]


--------------------------------------------------------------------------------
/bml/examples/circle.bml:
--------------------------------------------------------------------------------
 1 | # generate white circle
 2 | 
 3 | # normalize coordinates
 4 | uv = coord / resolution
 5 | 
 6 | # radius
 7 | radius = 0.5
 8 | 
 9 | # return white if distance of coords
10 | # from center is < 0.5, else black
11 | return [1, 1, 1, 4] if dist(uv, [0.5, 0.5]) < radius else [0, 0, 0, 1]


--------------------------------------------------------------------------------
/bml/examples/closing_circle.bml:
--------------------------------------------------------------------------------
1 | # cartoon-style closing circle
2 | 
3 | uv = coord / resolution
4 | distance = dist(uv, [0.5, 0.5])
5 | circle = distance < 1 - frame / (frame_count - 1)
6 | return frag if circle else [0, 0, 0, 1]


--------------------------------------------------------------------------------
/bml/examples/fractal_noise.bml:
--------------------------------------------------------------------------------
 1 | # generates fractal noise texture (WIP!)
 2 | 
 3 | macro random(st) {
 4 |     give fract(sin(dot((st).xy, [12.9898,78.233])) * 43758.5453123)
 5 | }
 6 | 
 7 | macro noise(st) {
 8 |     i = floor(st)
 9 |     f = fract(st)
10 | 
11 |     # Four corners in 2D of a tile
12 |     a = random(i)
13 |     b = random(i + [1, 0])
14 |     c = random(i + [0, 1])
15 |     d = random(i + [1, 1])
16 | 
17 |     u = f * f * (3.0 - 2.0 * f)
18 | 
19 |     give mix(a, b, u.x) +
20 |             (c - a) * u.y * (1.0 - u.x) +
21 |             (d - b) * u.x * u.y
22 | }
23 | 
24 | macro OCTAVES() 6
25 | 
26 | macro fbm(st) {
27 |     s = st
28 | 
29 |     # Initial values
30 |     value = 0.0
31 |     amplitude = 0.5
32 |     frequency = 0.0
33 | 
34 |     # Loop of octaves
35 |     repeat OCTAVES() {
36 |         value = value + amplitude * noise(s)
37 |         s = s * 2.0
38 |         amplitude = 0.5 * amplitude 
39 |     }
40 | 
41 |     give value
42 | }
43 | 
44 | st = coord / resolution
45 | 
46 | st = [
47 |     st.x * resolution.x / resolution.y,
48 |     st.y
49 | ]
50 | 
51 | color = [0; 3] + fbm(st * 3)
52 | 
53 | col = [color.x, color.y, color.z, 1]
54 | 
55 | return col


--------------------------------------------------------------------------------
/bml/examples/img/checkerboard.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/profsucrose/bml/24346a9e3e94a41015a314932b51d61d226d67f2/bml/examples/img/checkerboard.png


--------------------------------------------------------------------------------
/bml/examples/img/circle.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/profsucrose/bml/24346a9e3e94a41015a314932b51d61d226d67f2/bml/examples/img/circle.png


--------------------------------------------------------------------------------
/bml/examples/img/closing_circle_rocket.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/profsucrose/bml/24346a9e3e94a41015a314932b51d61d226d67f2/bml/examples/img/closing_circle_rocket.gif


--------------------------------------------------------------------------------
/bml/examples/img/fractal_noise.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/profsucrose/bml/24346a9e3e94a41015a314932b51d61d226d67f2/bml/examples/img/fractal_noise.png


--------------------------------------------------------------------------------
/bml/examples/img/invert_rocket.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/profsucrose/bml/24346a9e3e94a41015a314932b51d61d226d67f2/bml/examples/img/invert_rocket.png


--------------------------------------------------------------------------------
/bml/examples/img/mandelbrot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/profsucrose/bml/24346a9e3e94a41015a314932b51d61d226d67f2/bml/examples/img/mandelbrot.png


--------------------------------------------------------------------------------
/bml/examples/img/projected_julia.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/profsucrose/bml/24346a9e3e94a41015a314932b51d61d226d67f2/bml/examples/img/projected_julia.gif


--------------------------------------------------------------------------------
/bml/examples/img/quadrant_rocket.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/profsucrose/bml/24346a9e3e94a41015a314932b51d61d226d67f2/bml/examples/img/quadrant_rocket.png


--------------------------------------------------------------------------------
/bml/examples/img/rocket.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/profsucrose/bml/24346a9e3e94a41015a314932b51d61d226d67f2/bml/examples/img/rocket.png


--------------------------------------------------------------------------------
/bml/examples/img/sample_rocket.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/profsucrose/bml/24346a9e3e94a41015a314932b51d61d226d67f2/bml/examples/img/sample_rocket.png


--------------------------------------------------------------------------------
/bml/examples/img/sawtooth.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/profsucrose/bml/24346a9e3e94a41015a314932b51d61d226d67f2/bml/examples/img/sawtooth.gif


--------------------------------------------------------------------------------
/bml/examples/invert.bml:
--------------------------------------------------------------------------------
1 | # invert each pixel
2 | 
3 | return [1 - frag.r, 1 - frag.g, 1 - frag.b, frag.a]


--------------------------------------------------------------------------------
/bml/examples/mandelbrot.bml:
--------------------------------------------------------------------------------
 1 | # mandelbrot in BML
 2 | 
 3 | macro complex_mult(a, b) {
 4 |     give [a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x]
 5 | }
 6 | 
 7 | macro complex_abs(complex) {
 8 |     give sqrt(pow(complex.x, 2.0) + pow(complex.y, 2.0))
 9 | }
10 | 
11 | c = coord / resolution
12 | c = [mix(-2, 2, c.x), mix(-1, 1, c.y)] 
13 | 
14 | z = [0, 0]
15 | 
16 | abs = 0
17 | 
18 | n = 0
19 | 
20 | while abs <= 2, 100 {
21 |     abs = complex_abs(z)
22 |     z = complex_mult(z, z) + c
23 |     n = n + 1
24 | }
25 | 
26 | col = n / 100
27 | return [col, col, col, 1]


--------------------------------------------------------------------------------
/bml/examples/mod_sawtooth.bml:
--------------------------------------------------------------------------------
 1 | # mod sawtooth animation
 2 | 
 3 | x = coord.x * abs(sin(frame / (frame_count - 1) * 3.14159))
 4 | y = mod(x, 80) + 200
 5 | 
 6 | return {
 7 |     give [1, 0, 0, 1]
 8 | } if abs(resolution.y - coord.y - y) < 2 else {
 9 |     give [1; 4]
10 | }


--------------------------------------------------------------------------------
/bml/examples/projected_julia.bml:
--------------------------------------------------------------------------------
 1 | # generate arbitrary Julia Set w/ projection + rotation as gif
 2 | 
 3 | macro complex_mult(a, b) {
 4 |     give [a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x]
 5 | }
 6 | 
 7 | macro complex_abs(complex) {
 8 |     give sqrt(pow(complex.x, 2.0) + pow(complex.y, 2.0))
 9 | }
10 | 
11 | z = coord / resolution
12 | z = [mix(-2, 2, z.x), mix(-1, 1, z.y)] 
13 | 
14 | z = ([z.x, z.y, 0, 1] * perspective(45.0, 0.0, 100.0) * rotate_x(mix(0, 5 * 3.14159, frame / frame_count)))
15 | 
16 | z = z.xy / z.z
17 | 
18 | # c = [0, 0]
19 | c = [-0.12, -0.77]
20 | 
21 | abs = 0
22 | 
23 | n = 0
24 | 
25 | while abs <= 2, 100 {
26 |     abs = complex_abs(z)
27 |     z = complex_mult(z, z) + c
28 |     n = n + 1
29 | }
30 | 
31 | col = n / 10
32 | return [col, col, col, 1]
33 | 
34 | 
35 | 


--------------------------------------------------------------------------------
/bml/examples/quadrant.bml:
--------------------------------------------------------------------------------
1 | # splits texture into quadrants
2 | 
3 | quadrant = abs(coord - resolution/2) / resolution
4 | 
5 | return sample(quadrant.xy * sign(coord) * 2)


--------------------------------------------------------------------------------
/bml/examples/sample.bml:
--------------------------------------------------------------------------------
 1 | # wavy distortion using sample()
 2 | 
 3 | sample_coords = coord
 4 | 
 5 | sample_coords = [
 6 |     sample_coords.x * mix(0.9, 1.3, (sin(coord.x / 5) + 1) / 2), 
 7 |     sample_coords.y
 8 | ]
 9 | 
10 | return sample(sample_coords / resolution)


--------------------------------------------------------------------------------
/bml/src/ast.rs:
--------------------------------------------------------------------------------
   1 | use core::panic;
   2 | use image::{ImageBuffer, Rgba};
   3 | use lasso::{Rodeo, Spur};
   4 | use std::collections::HashMap;
   5 | 
   6 | use crate::logger::{report, ErrorType};
   7 | 
   8 | #[derive(Debug, Copy, Clone, PartialEq)]
   9 | pub enum Op {
  10 |     Add,
  11 |     Sub,
  12 |     Div,
  13 |     Mul,
  14 |     More,
  15 |     Less,
  16 |     MoreEq,
  17 |     LessEq,
  18 |     Equal,
  19 |     NotEqual
  20 | }
  21 | 
  22 | #[derive(Copy, Clone, Debug, PartialEq)]
  23 | pub enum Field {
  24 |     X,
  25 |     Y,
  26 |     Z,
  27 |     W,
  28 | }
  29 | 
  30 | #[derive(Copy, Clone, Debug, PartialEq)]
  31 | pub struct Swizzle(
  32 |     pub Field,
  33 |     pub Option<Field>,
  34 |     pub Option<Field>,
  35 |     pub Option<Field>,
  36 | );
  37 | 
  38 | // #[derive(PartialEq, Clone, Copy, Debug)]
  39 | // pub enum Vector {
  40 | //     Vec2(f32, f32),
  41 | //     Vec3(f32, f32, f32),
  42 | //     Vec4(f32, f32, f32, f32),
  43 | // }
  44 | 
  45 | // #[derive(PartialEq, Clone, Copy, Debug)]
  46 | // pub enum Matrix {
  47 | //     Mat2([Vector; 2]),
  48 | //     Mat3([Vector; 3]),
  49 | //     Mat4([Vector; 4]),
  50 | // }
  51 | 
  52 | // #[derive(PartialEq, Clone, Copy, Debug)]
  53 | // pub enum Val {
  54 | //     Float(f32),
  55 | //     Vec(Vector),
  56 | //     Mat(Matrix)
  57 | // }
  58 | 
  59 | #[derive(PartialEq, Clone, Copy, Debug)]
  60 | pub enum Val {
  61 |     Float(f32),
  62 |     Vec2(f32, f32),
  63 |     Vec3(f32, f32, f32),
  64 |     Vec4(f32, f32, f32, f32),
  65 | 
  66 |     // matrices are column-major
  67 |     Mat2([f32; 2], [f32; 2]),
  68 |     Mat3([f32; 3], [f32; 3], [f32; 3]),
  69 |     Mat4([f32; 4], [f32; 4], [f32; 4], [f32; 4])
  70 | }
  71 | 
  72 | use Val::*;
  73 | 
  74 | mod math {
  75 |     pub fn rad(x: f32) -> f32 {
  76 |         x * std::f32::consts::PI / 180.0
  77 |     }
  78 | 
  79 |     pub fn deg(x: f32) -> f32 {
  80 |         x * 180.0 / std::f32::consts::PI
  81 |     }
  82 | 
  83 |     pub fn inv_sqrt(x: f32) -> f32 {
  84 |         let i = x.to_bits();
  85 |         let i = 0x5f3759df - (i >> 1);
  86 |         let y = f32::from_bits(i);
  87 | 
  88 |         y * (1.5 - 0.5 * x * y * y)
  89 |     }
  90 | 
  91 |     pub fn mix(x: f32, y: f32, a: f32) -> f32 {
  92 |         x * (1.0 - a) + y * a
  93 |     }
  94 | }
  95 | 
  96 | macro_rules! vector_map {
  97 |     ($self:ident, $name:expr, $op:expr) => {{
  98 |         if !$self.is_vector_or_scalar() {
  99 |             return Err(format!("Expected {}(float) or {}(vector), got radians({:?})", $name, $name, $self))
 100 |         }
 101 |         Ok($self.map($op))
 102 |     }};
 103 | }
 104 | 
 105 | impl Val {
 106 |     pub fn float(self) -> Option<f32> {
 107 |         match self {
 108 |             Self::Float(x) => Some(x),
 109 |             _ => None,
 110 |         }
 111 |     }
 112 | 
 113 |     pub fn map<F: FnMut(f32) -> f32>(self, mut f: F) -> Val {
 114 |         match self {
 115 |             Float(x) => Float(f(x)),
 116 |             Vec2(x, y) => Vec2(f(x), f(y)),
 117 |             Vec3(x, y, z) => Vec3(f(x), f(y), f(z)),
 118 |             Vec4(x, y, z, w) => Vec4(f(x), f(y), f(z), f(w)),
 119 |             Mat2(row0, row1) => Mat2(row0.map(|x| f(x)), row1.map(|x| f(x))),
 120 |             Mat3(row0, row1, row2) => {
 121 |                 Mat3(row0.map(|x| f(x)), row1.map(|x| f(x)), row2.map(|x| f(x)))
 122 |             }
 123 |             Mat4(row0, row1, row2, row3) => Mat4(
 124 |                 row0.map(|x| f(x)),
 125 |                 row1.map(|x| f(x)),
 126 |                 row2.map(|x| f(x)),
 127 |                 row3.map(|x| f(x)),
 128 |             ),
 129 |         }
 130 |     }
 131 | 
 132 |     pub fn zipmap3<F: FnMut(f32, f32, f32) -> f32>(self, o1: Self, o2: Self, mut f: F) -> Result<Val, String> {
 133 |         match (self, o1, o2) {
 134 |             (Float(x), Float(y), Float(z)) => Ok(Float(f(x, y, z))),
 135 |             (Vec2(x0, x1), Vec2(y0, y1), Vec2(z0, z1)) => Ok(Vec2(f(x0, y0, z0), f(x1, y1, z1))),
 136 |             (Vec3(x0, x1, x2), Vec3(y0, y1, y2), Vec3(z0, z1, z2)) => {
 137 |                 Ok(Vec3(f(x0, y0, z0), f(x1, y1, z1), f(x2, y2, z2)))
 138 |             }
 139 |             (Vec4(x0, x1, x2, x3), Vec4(y0, y1, y2, y3), Vec4(z0, z1, z2, z3)) => {
 140 |                 Ok(Vec4(f(x0, y0, z0), f(x1, y1, z1), f(x2, y2, z2), f(x3, y3, z3)))
 141 |             }
 142 |             _ => Err(
 143 |                 format!(
 144 |                     "expected all args to zipmap3 be vectors of the same type, got {:?}, {:?}, {:?}",
 145 |                     self, o1, o2
 146 |                 )
 147 |             ),
 148 |         }
 149 |     }
 150 | 
 151 |     pub fn zipmap<F: FnMut(f32, f32) -> f32>(self, o: Self, mut f: F) -> Result<Val, String> {
 152 |         match (self, o) {
 153 |             (Float(l), Float(r)) => Ok(Float(f(l, r))),
 154 |             (Vec2(lx, ly), Float(r)) => Ok(Vec2(f(lx, r), f(ly, r))),
 155 |             (Vec3(lx, ly, lz), Float(r)) => Ok(Vec3(f(lx, r), f(ly, r), f(lz, r))),
 156 |             (Vec4(lx, ly, lz, lw), Float(r)) => Ok(Vec4(f(lx, r), f(ly, r), f(lz, r), f(lw, r))),
 157 | 
 158 |             (Float(r), Vec2(lx, ly)) => Ok(Vec2(f(r, lx), f(r, ly))),
 159 |             (Float(r), Vec3(lx, ly, lz)) => Ok(Vec3(f(r, lx), f(r, ly), f(r, lz))),
 160 |             (Float(r), Vec4(lx, ly, lz, lw)) => Ok(Vec4(f(r, lx), f(r, ly), f(r, lz), f(r, lw))),
 161 | 
 162 |             (Vec2(lx, ly), Vec2(rx, ry)) => Ok(Vec2(f(lx, rx), f(ly, ry))),
 163 |             (Vec3(lx, ly, lz), Vec3(rx, ry, rz)) => Ok(Vec3(f(lx, rx), f(ly, ry), f(lz, rz))),
 164 |             (Vec4(lx, ly, lz, lw), Vec4(rx, ry, rz, rw)) => {
 165 |                 Ok(Vec4(f(lx, rx), f(ly, ry), f(lz, rz), f(lw, rw)))
 166 |             }
 167 | 
 168 |             (x, y) => Err(format!("Expected float `op` float, vector `op` float, float `op` vector, or same-size vector `op` vector, got {:?} `op` {:?}", x, y))
 169 |         }
 170 |     }
 171 | 
 172 |     pub fn get_field(&self, f: Field) -> Result<f32, String> {
 173 |         use Val::*;
 174 |         match f {
 175 |             Field::X => match *self {
 176 |                 Float(_) => Err("Tried to get swizzle float".to_string()),
 177 |                 Vec2(x, _) => Ok(x),
 178 |                 Vec3(x, _, _) => Ok(x),
 179 |                 Vec4(x, _, _, _) => Ok(x),
 180 |                 x => Err(format!("Expecting vector when swizzling `x` / `r` field, got {:?}", x))
 181 |             },
 182 |             Field::Y => match *self {
 183 |                 Float(_) => Err("Tried to get swizzle float".to_string()),
 184 |                 Vec2(_, y) => Ok(y),
 185 |                 Vec3(_, y, _) => Ok(y),
 186 |                 Vec4(_, y, _, _) => Ok(y),
 187 |                 x => Err(format!("Expecting vector when swizzling `y` / `g` field, got {:?}", x))
 188 |             },
 189 |             Field::Z => match *self {
 190 |                 Float(_) => Err("Tried to get swizzle float".to_string()),
 191 |                 Vec2(_, _) => Err("Tried to get `z` / `b` field from vec2".to_string()),
 192 |                 Vec3(_, _, z) => Ok(z),
 193 |                 Vec4(_, _, z, _) => Ok(z),
 194 |                 x => Err(format!("Expecting vector when swizzling `z` / `b` field, got {:?}", x))
 195 |             },
 196 |             Field::W => match *self {
 197 |                 Float(_) => Err("Tried to get swizzle float".to_string()),
 198 |                 Vec2(_, _) => Err("vec2 has no `w` / `a` field".to_string()),
 199 |                 Vec3(_, _, _) => Err("vec3 has no `w` / `a` field".to_string()),
 200 |                 Vec4(_, _, _, w) => Ok(w),
 201 |                 x => Err(format!("Expecting vector when swizzling `w` / `a` field, got {:?}", x))
 202 |             },
 203 |         }
 204 |     }
 205 | 
 206 |     pub fn translate(x: f32, y: f32, z: f32) -> Val {
 207 |         Mat4(
 208 |             [x,   0.0, 0.0, 0.0],
 209 |             [0.0,   y, 0.0, 0.0],
 210 |             [0.0, 0.0,   z, 0.0],
 211 |             [0.0, 0.0, 0.0, 1.0],
 212 |         )
 213 |     }
 214 | 
 215 |     pub fn rotate_x(angle: f32) -> Val {
 216 |         let c = angle.cos();
 217 |         let s = angle.sin();
 218 | 
 219 |         Mat4(
 220 |             [1.0, 0.0, 0.0, 0.0],
 221 |             [0.0,   c,   s, 0.0],
 222 |             [0.0,  -s,   c, 0.0],
 223 |             [0.0, 0.0, 0.0, 1.0]
 224 |         )
 225 |     }
 226 | 
 227 |     pub fn rotate_y(angle: f32) -> Val {
 228 |         let c = angle.cos();
 229 |         let s = angle.sin();
 230 | 
 231 |         Mat4(
 232 |             [  c, 0.0,  -s, 0.0],
 233 |             [0.0, 1.0, 0.0, 0.0],
 234 |             [  s, 0.0,   c, 0.0],
 235 |             [0.0, 0.0, 0.0, 1.0]
 236 |         )
 237 |     }
 238 | 
 239 |     pub fn rotate_z(angle: f32) -> Val {
 240 |         let c = angle.cos();
 241 |         let s = angle.sin();
 242 | 
 243 |         Mat4(
 244 |             [  c,   s, 0.0, 0.0],
 245 |             [ -s,   c, 0.0, 0.0],
 246 |             [0.0, 0.0, 1.0, 0.0],
 247 |             [0.0, 0.0, 0.0, 1.0]
 248 |         )
 249 |     }
 250 | 
 251 |     pub fn rotate(yaw: f32, pitch: f32, roll: f32) -> Val {
 252 |         Val::rotate_z(yaw).mult(Val::rotate_y(pitch).mult(Val::rotate_x(roll)).unwrap()).unwrap()
 253 |     }
 254 | 
 255 |     pub fn scale(s: f32) -> Val {
 256 |         Mat4(
 257 |             [  s, 0.0, 0.0, 0.0],
 258 |             [0.0,   s, 0.0, 0.0],
 259 |             [0.0, 0.0,   s, 0.0],
 260 |             [0.0, 0.0, 0.0,   s]
 261 |         )
 262 |     }
 263 | 
 264 |     pub fn ortho(near: f32, far: f32, left: f32, right: f32, top: f32, bottom: f32) -> Val {
 265 |         Mat4(
 266 |             [ 2.0 / (right - left),                 0.0,                0.0, -(right + left) / (right - left) ],
 267 |             [                  0.0, 2.0 / (top - bottom),               0.0, -(top + bottom) / (top - bottom) ],
 268 |             [                  0.0,                  0.0, -2.0/(far - near),     -(far + near) / (far - near) ],
 269 |             [                  0.0,                  0.0,               0.0,                             1.0 ]
 270 |         )
 271 |     }
 272 | 
 273 |     pub fn perspective(fov: f32, near: f32, far: f32) -> Val {
 274 |         let s = 1.0 / (fov / 2.0 * std::f32::consts::PI / 180.0);
 275 | 
 276 |         Mat4(
 277 |             [s, 0.0, 0.0, 0.0],
 278 |             [0.0, s, 0.0, 0.0],
 279 |             [0.0, 0.0, -far / (far - near), -1.0],
 280 |             [0.0, 0.0, -(far * near) / (far - near), 0.0]
 281 |         )
 282 |     }
 283 | 
 284 |     pub fn lookat(&self, /* from */ to: Self) -> Result<Val, String> {
 285 |         match (self, to) {
 286 |             (Vec3(_, _, _), Vec3(_, _, _)) => {},
 287 |             (x, y) => return Err(format!("Expected lookat(vec3, vec3), got lookat({:?}, {:?})", x, y))
 288 |         }
 289 | 
 290 |         let up = Vec3(0.0, 1.0, 0.0);
 291 |         let forward = self.sub(to)?.norm()?;
 292 |         let right = up.norm()?.cross(forward).unwrap();
 293 | 
 294 |         // center row is up-axis Vec3(0, 1, 0)
 295 | 
 296 |         Ok(Mat4(
 297 |             [right.get_field(Field::X)?, 0.0, forward.get_field(Field::X)?, self.get_field(Field::X)?],
 298 |             [right.get_field(Field::Y)?, 1.0, forward.get_field(Field::Y)?, self.get_field(Field::Y)?],
 299 |             [right.get_field(Field::Z)?, 0.0, forward.get_field(Field::Z)?, self.get_field(Field::Z)?],
 300 |             [                      0.0, 0.0,                         0.0,                      1.0]
 301 |         ))
 302 |     }
 303 | 
 304 |     pub fn add(&self, o: Self) -> Result<Val, String> {
 305 |         self.zipmap(o, |x, y| x + y)
 306 |     }
 307 | 
 308 |     pub fn sub(&self, o: Self) -> Result<Val, String> {
 309 |         self.zipmap(o, |x, y| x - y)
 310 |     }
 311 |     
 312 |     pub fn div(&self, o: Self) -> Result<Val, String> {
 313 |         self.zipmap(o, |x, y| x / y)
 314 |     }
 315 | 
 316 |     pub fn mult(&self, o: Self) -> Result<Val, String> {
 317 |         match (*self, o) {
 318 |             (Float(_), Float(_))
 319 |                 | (Vec2(_, _), Vec2(_, _))
 320 |                 | (Vec3(_, _, _), Vec3(_, _, _))
 321 |                 | (Vec4(_, _, _, _), Vec4(_, _, _, _))
 322 |             => self.zipmap(o, |x, y| x * y),
 323 | 
 324 |             (Float(a), Vec2(_, _) | Vec3(_, _, _) | Vec4(_, _, _, _)) => Ok(o.map(|x| a * x)),
 325 |             
 326 |             (Vec2(_, _) | Vec3(_, _, _) | Vec4(_, _, _, _), Float(a)) => Ok(self.map(|x| x * a)),
 327 | 
 328 |             (Float(x), Mat2(col0, col1)) => Ok(Mat2([col0[0] * x, col0[1] * x], [col1[0] * x, col1[1] * x])),
 329 |             (Float(x), Mat3(col0, col1, col2)) => Ok(Mat3([col0[0] * x, col0[1] * x, col0[2] * x], [col1[0] * x, col1[1] * x, col1[2] * x], [col2[0] * x, col2[1] * x, col2[2] * x])),
 330 |             (Float(x), Mat4(col0, col1, col2, col3)) => Ok(Mat4([col0[0] * x, col0[1] * x, col0[2] * x, col0[3] * x], [col1[0] * x, col1[1] * x, col1[2] * x, col1[3] * x], [col2[0] * x, col2[1] * x, col2[2] * x, col2[3] * x], [col3[0] * x, col3[1] * x, col3[2] * x, col3[3] * x])),
 331 |             
 332 |             (Vec2(x, y), Mat2(col0, col1)) => Ok(Vec2(x * col0[0] + y * col0[0], x * col1[0] + y * col1[0])),
 333 |             (Vec3(x, y, z), Mat3(col0, col1, col2)) => Ok(Vec3(x * col0[0] + y * col0[1] + z * col0[2], x * col1[0] + y * col1[1] + z * col1[2], x * col2[0] + y * col2[1] + z * col2[2])), 
 334 |             (Vec4(x, y, z, w), Mat4(col0, col1, col2, col3)) => Ok(Vec4(x * col0[0] + y * col0[1] + z * col0[2] + w * col0[3], x * col1[0] + y * col1[1] + z * col1[2] + w * col1[3], x * col2[0] + y * col2[1] + z * col2[2] + w * col2[3], x * col3[0] + y * col3[1] + z * col3[2] + w * col3[3])),
 335 |             
 336 |             (Mat2(col0, col1), Vec2(x, y)) => Ok(Vec2(col0[0] * x + col1[0] * y, col0[1] * x + col1[1] * y)),
 337 |             (Mat3(col0, col1, col2), Vec3(x, y, z)) => Ok(Vec3(col0[0] * x + col1[0] * y + col2[0] * z, col0[1] * x + col1[1] * y + col2[1] * z, col0[2] * x + col1[2] * y + col2[2] * z)),
 338 |             (Mat4(col0, col1, col2, col3), Vec4(x, y, z, w)) => Ok(Vec4(col0[0] * x + col1[0] * y + col2[0] * z + col3[0] * w, col0[1] * x + col1[1] * y + col2[1] * z + col3[1] * w, col0[2] * x + col1[2] * y + col2[2] * z + col3[2] * w, col0[3] * x + col1[3] * y + col2[3] * z + col3[3] * w)),
 339 | 
 340 |             (Mat2(a0, a1), Mat2(b0, b1)) => Ok(
 341 |                 Mat2(
 342 |                     [a0[0] * b0[0] + a1[0] * b0[1], a0[1] * b0[0] + a1[1] * b0[1]],
 343 |                     [a0[0] * b1[0] + a1[0] * b1[1], a0[1] * b1[0] + a1[1] * b1[1]]
 344 |                 )
 345 |             ),
 346 | 
 347 |             (Mat3(a0, a1, a2), Mat3(b0, b1, b2)) => Ok(
 348 |                 Mat3(
 349 |                     [a0[0] * b0[0] + a1[0] * b0[1] + a2[0] * b0[2], a0[1] * b0[0] + a1[1] * b0[1] + a2[1] * b0[2], a0[2] * b0[0] + a1[2] * b0[1] + a2[2] * b0[2]],
 350 |                     [a0[0] * b1[0] + a1[0] * b1[1] + a2[0] * b1[2], a0[1] * b1[0] + a1[1] * b1[1] + a2[1] * b1[2], a0[2] * b1[0] + a1[2] * b1[1] + a2[2] * b1[2]],
 351 |                     [a0[0] * b2[0] + a1[0] * b2[1] + a2[0] * b2[2], a0[1] * b2[0] + a1[1] * b2[1] + a2[1] * b2[2], a0[2] * b2[0] + a1[2] * b2[1] + a2[2] * b2[2]]
 352 |                 )
 353 |             ),
 354 | 
 355 |             (Mat4(a0, a1, a2, a3), Mat4(b0, b1, b2, b3)) => Ok(
 356 |                 Mat4(
 357 |                     [a0[0] * b0[0] + a1[0] * b0[1] + a2[0] * b0[2] + a3[0] * b0[3], a0[1] * b0[0] + a1[1] * b0[1] + a2[1] * b0[2] + a3[1] * b0[3], a0[2] * b0[0] + a1[2] * b0[1] + a2[2] * b0[2] + a3[2] * b0[3], a0[3] * b0[0] + a1[3] * b0[1] + a2[3] * b0[2] + a3[3] * b0[3]],
 358 |                     [a0[0] * b1[0] + a1[0] * b1[1] + a2[0] * b1[2] + a3[0] * b1[3], a0[1] * b1[0] + a1[1] * b1[1] + a2[1] * b1[2] + a3[1] * b1[3], a0[2] * b1[0] + a1[2] * b1[1] + a2[2] * b1[2] + a3[2] * b1[3], a0[3] * b1[0] + a1[3] * b1[1] + a2[3] * b1[2] + a3[3] * b1[3]],
 359 |                     [a0[0] * b2[0] + a1[0] * b2[1] + a2[0] * b2[2] + a3[0] * b2[3], a0[1] * b2[0] + a1[1] * b2[1] + a2[1] * b2[2] + a3[1] * b2[3], a0[2] * b2[0] + a1[2] * b2[1] + a2[2] * b2[2] + a3[2] * b2[3], a0[3] * b2[0] + a1[3] * b2[1] + a2[3] * b2[2] + a3[3] * b2[3]],
 360 |                     [a0[0] * b3[0] + a1[0] * b3[1] + a2[0] * b3[2] + a3[0] * b3[3], a0[1] * b3[0] + a1[1] * b3[1] + a2[1] * b3[2] + a3[1] * b3[3], a0[2] * b3[0] + a1[2] * b3[1] + a2[2] * b3[2] + a3[2] * b3[3], a0[3] * b3[0] + a1[3] * b3[1] + a2[3] * b3[2] + a3[3] * b3[3]]
 361 |                 )
 362 |             ),
 363 | 
 364 |             _ => Err(format!("Expected vecX * vecX, vecX * matX, matX * vecX, float * vecX, or float * matX, got {:?} * {:?}", self, o))
 365 |         }
 366 |     }
 367 | 
 368 |     pub fn index_matrix(&self, f: usize) -> Result<Val, String> {
 369 |         match (self, f) {
 370 |             (&Mat2(col0, _), 0) => Ok(Vec2(col0[0], col0[1])),
 371 |             (&Mat2(_, col1), 1) => Ok(Vec2(col1[0], col1[1])),
 372 |             (&Mat2(_, _), index) => Err(format!(
 373 |                 "Expected 0 <= index <= 1 when accessing mat2, got {}",
 374 |                 index
 375 |             )),
 376 | 
 377 |             (&Mat3(col0, _, _), 0) => Ok(Vec3(col0[0], col0[1], col0[2])),
 378 |             (&Mat3(_, col1, _), 1) => Ok(Vec3(col1[0], col1[1], col1[2])),
 379 |             (&Mat3(_, _, col2), 2) => Ok(Vec3(col2[0], col2[1], col2[2])),
 380 |             (&Mat3(_, _, _), index) => Err(format!(
 381 |                 "Expected 0 <= index <= 2, when accessing mat3, got {}",
 382 |                 index
 383 |             )),
 384 | 
 385 |             (&Mat4(col0, _, _, _), 0) => Ok(Vec4(col0[0], col0[1], col0[2], col0[3])),
 386 |             (&Mat4(_, col1, _, _), 1) => Ok(Vec4(col1[0], col1[1], col1[2], col1[3])),
 387 |             (&Mat4(_, _, col2, _), 2) => Ok(Vec4(col2[0], col2[1], col2[2], col2[3])),
 388 |             (&Mat4(_, _, _, col3), 3) => Ok(Vec4(col3[0], col3[1], col3[2], col3[3])),
 389 |             (&Mat4(_, _, _, _), index) => Err(format!(
 390 |                 "Expected 0 <= index <= 3, when accessing mat4, got {}",
 391 |                 index
 392 |             )),
 393 | 
 394 |             (accessor, _) => Err(format!("Expected matrix when indexing, got {:?}", accessor)),
 395 |         }
 396 |     }
 397 | 
 398 |     pub fn is_vector_or_scalar(&self) -> bool {
 399 |         match self {
 400 |             Float(_) | Vec2(_, _) | Vec3(_, _, _) | Vec4(_, _, _, _) => true,
 401 |             _ => false
 402 |         }
 403 |     }
 404 | 
 405 |     pub fn radians(&self) -> Result<Val, String> {
 406 |         vector_map!(self, "radians", math::rad)
 407 |     }
 408 | 
 409 |     pub fn degrees(&self) -> Result<Val, String> {
 410 |         vector_map!(self, "degrees", math::deg)
 411 |     }
 412 | 
 413 |     pub fn sin(&self) -> Result<Val, String> {
 414 |         vector_map!(self, "sin", f32::sin)
 415 |     }
 416 | 
 417 |     pub fn cos(&self) -> Result<Val, String> {
 418 |         vector_map!(self, "cos", f32::cos)
 419 |     }
 420 | 
 421 |     pub fn tan(&self) -> Result<Val, String> {
 422 |         vector_map!(self, "tan", f32::tan)
 423 |     }
 424 | 
 425 |     pub fn asin(&self) -> Result<Val, String> {
 426 |         vector_map!(self, "asin", f32::asin)
 427 |     }
 428 | 
 429 |     pub fn acos(&self) -> Result<Val, String> {
 430 |         vector_map!(self, "acos", f32::acos)
 431 |     }
 432 | 
 433 |     pub fn atan(&self) -> Result<Val, String> {
 434 |         vector_map!(self, "atan", f32::atan)
 435 |     }
 436 | 
 437 |     pub fn exp(&self) -> Result<Val, String> {
 438 |         vector_map!(self, "exp", f32::exp)
 439 |     }
 440 | 
 441 |     pub fn log(&self) -> Result<Val, String> {
 442 |         vector_map!(self, "log", |x| f32::log(std::f32::consts::E, x))
 443 |     }
 444 | 
 445 |     pub fn sqrt(&self) -> Result<Val, String> {
 446 |         vector_map!(self, "sqrt", f32::sqrt)
 447 |     }
 448 | 
 449 |     pub fn invsqrt(&self) -> Result<Val, String> {
 450 |         vector_map!(self, "invsqrt", math::inv_sqrt)
 451 |     }
 452 | 
 453 |     pub fn abs(&self) -> Result<Val, String> {
 454 |         vector_map!(self, "abs", f32::abs)
 455 |     }
 456 | 
 457 |     pub fn sign(&self) -> Result<Val, String> {
 458 |         vector_map!(self, "sign", f32::signum)
 459 |     }
 460 | 
 461 |     pub fn floor(&self) -> Result<Val, String> {
 462 |         vector_map!(self, "floor", f32::floor)
 463 |     }
 464 | 
 465 |     pub fn ceil(&self) -> Result<Val, String> {
 466 |         vector_map!(self, "ceil", f32::ceil)
 467 |     }
 468 | 
 469 |     pub fn fract(&self) -> Result<Val, String> {
 470 |         vector_map!(self, "fract", f32::fract)
 471 |     }
 472 | 
 473 |     pub fn pow(&self, exp: Self) -> Result<Val, String> {
 474 |         match (self, exp) {
 475 |             (Float(_), Float(_))
 476 |                 | (Vec2(_, _), Vec2(_, _))
 477 |                 | (Vec3(_, _, _), Vec3(_, _, _))
 478 |                 | (Vec4(_, _, _, _), Vec4(_, _, _, _))
 479 |             => self.zipmap(exp, |x, exp| x.powf(exp)),
 480 | 
 481 |             (Vec2(_, _), Float(exp))
 482 |                 | (Vec3(_, _, _), Float(exp))
 483 |                 | (Vec4(_, _, _, _), Float(exp))
 484 |             => Ok(self.map(|x| x.powf(exp))),
 485 | 
 486 |             _ => Err(format!("Expected pow(float, float), pow(vec2, vec2), pow(vec3, vec3), pow(vec4, vec4), pow(vec2, float), pow(vec3, float), pow(vec4, float), got pow({:?}, {:?}", self, exp))
 487 |         }
 488 |     }
 489 | 
 490 |     pub fn dot(&self, o: Self) -> Result<Val, String> {
 491 |         match (self, o) {
 492 |             (Vec2(x0, y0), Vec2(x1, y1)) => Ok(Float(x0 * x1 + y0 * y1)),
 493 |             (Vec3(x0, y0, z0), Vec3(x1, y1, z1)) => Ok(Float(x0 * x1 + y0 * y1 + z0 * z1)),
 494 |             (Vec4(x0, y0, z0, w0), Vec4(x1, y1, z1, w1)) => {
 495 |                 Ok(Float(x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1))
 496 |             }
 497 |             _ => Err(format!(
 498 |                 "Expected dot(vec2, vec2), dot(vec3, vec3), dot(vec4, vec4), got dot({:?}, {:?})",
 499 |                 self, o
 500 |             )),
 501 |         }
 502 |     }
 503 | 
 504 |     pub fn modulo(&self, o: Self) -> Result<Val, String> {
 505 |         match (self, o) {
 506 |             (Float(_), Float(_))
 507 |                 | (Vec2(_, _), Vec2(_, _))
 508 |                 | (Vec3(_, _, _), Vec3(_, _, _))
 509 |                 | (Vec4(_, _, _, _), Vec4(_, _, _, _))
 510 |             => Ok(self.zipmap(o, |x, y| x % y)?),
 511 |             _ => Err(format!("Expected mod(float, float), mod(vec2, vec2), mod(vec3, vec3), mod(vec4, vec4), got mod({:?}, {:?})", self, o))
 512 |         }
 513 |     }
 514 | 
 515 |     pub fn min(&self, val: Self) -> Result<Val, String> {
 516 |         match (self, val) {
 517 |             (Float(_), Float(_))
 518 |                 | (Vec2(_, _), Vec2(_, _))
 519 |                 | (Vec3(_, _, _), Vec3(_, _, _))
 520 |                 | (Vec4(_, _, _, _), Vec4(_, _, _, _))
 521 |             => Ok(self.zipmap(val, |x, y| x.min(y))?),
 522 |             _ => Err(format!("Expected min(float, float), min(vec2, vec2), min(vec3, vec3), min(vec4, vec4), got min({:?}, {:?})", self, val))
 523 |         }
 524 |     }
 525 | 
 526 |     pub fn max(&self, val: Self) -> Result<Val, String> {
 527 |         match (self, val) {
 528 |             (Float(_), Float(_))
 529 |                 | (Vec2(_, _), Vec2(_, _))
 530 |                 | (Vec3(_, _, _), Vec3(_, _, _))
 531 |                 | (Vec4(_, _, _, _), Vec4(_, _, _, _))
 532 |             => Ok(self.zipmap(val, |x, y| x.max(y))?),
 533 |             _ => Err(format!("Expected max(float, float), max(vec2, vec2), max(vec3, vec3), max(vec4, vec4), got max({:?}, {:?})", self, val))
 534 |         }
 535 |     }
 536 | 
 537 |     pub fn clamp(&self, min: Self, max: Self) -> Result<Val, String> {
 538 |         match (self, min, max) {
 539 |             (Float(_), Float(_), Float(_))
 540 |                 | (Vec2(_, _), Vec2(_, _), Vec2(_, _))
 541 |                 | (Vec3(_, _, _), Vec3(_, _, _), Vec3(_, _, _))
 542 |                 | (Vec4(_, _, _, _), Vec4(_, _, _, _), Vec4(_, _, _, _))
 543 |             => Ok(self.zipmap3(min, max, |x, y, z| x.clamp(y, z))?),
 544 | 
 545 |             (Vec2(_, _), Float(min), Float(max))
 546 |                 | (Vec3(_, _, _), Float(min), Float(max))
 547 |                 | (Vec4(_, _, _, _), Float(min), Float(max))
 548 |             => Ok(self.map(|x| x.clamp(min, max))),
 549 | 
 550 |             _ => Err(format!("Expected clamp(float, float, float), clamp(vec2, vec2, vec2), clamp(vec3, vec3, vec3), clamp(vec4, vec4, vec4), clamp(vec2, float, float), clamp(vec3, float float), clamp(vec4, float, float), got clamp({:?}, {:?}, {:?})", self, min, max))
 551 |         }
 552 |     }
 553 | 
 554 |     pub fn mix(&self, y: Self, a: Self) -> Result<Val, String> {
 555 |         match (self, y, a) {
 556 |             (Float(_), Float(_), Float(_))
 557 |                 | (Vec2(_, _), Vec2(_, _), Vec2(_, _))
 558 |                 | (Vec3(_, _, _), Vec3(_, _, _), Vec3(_, _, _))
 559 |                 | (Vec4(_, _, _, _), Vec4(_, _, _, _), Vec4(_, _, _, _))
 560 |             => Ok(self.zipmap3(y, a, math::mix)?),
 561 | 
 562 |             (Vec2(_, _), Vec2(_, _), Float(a))
 563 |                 | (Vec3(_, _, _), Vec3(_, _, _), Float(a))
 564 |                 | (Vec4(_, _, _, _), Vec4(_, _, _, _), Float(a))
 565 |             => Ok(self.zipmap(y, |x, y| math::mix(x, y, a))?),
 566 | 
 567 |             _ => Err(format!("Expected mix(float, float, float), mix(vec2, vec2, float), mix(vec3, vec3, float), mix(vec4, vec4, float), mix(vec2, vec2, vec2), mix(vec3, vec3, vec3), mix(vec4, vec4, vec4), got mix({:?}, {:?}. {:?}", self, y, a))
 568 |         }
 569 |     }
 570 | 
 571 |     pub fn step(&self, x: Self) -> Result<Val, String> {
 572 |         match (self, x) {
 573 |             (Float(_), Float(_))
 574 |                 | (Vec2(_, _), Vec2(_, _))
 575 |                 | (Vec3(_, _, _), Vec3(_, _, _))
 576 |                 | (Vec4(_, _, _, _), Vec4(_, _, _, _))
 577 |             => Ok(self.zipmap(x, |edge, x| if x < edge { 0.0 } else { 1.0 })?),
 578 | 
 579 |             (Float(a), Vec2(_, _))
 580 |                 | (Float(a), Vec3(_, _, _))
 581 |                 | (Float(a), Vec4(_, _, _, _))
 582 |             => Ok(x.map(|x| if x < *a { 0.0 } else { 1.0 })),
 583 | 
 584 |             _ => Err(format!("Expected step(float, float), step(float, vec2), step(float, vec3), step(float, vec4), step(vec2, vec2), step(vec3, vec3), step(vec4, vec4), got step({:?}, {:?})", self, x))
 585 |         }
 586 |     }
 587 | 
 588 |     pub fn smoothstep(&self, edge1: Self, x: Self) -> Result<Val, String> {
 589 |         match (self, edge1, x) {
 590 |             (Float(_), Float(_), Float(_))
 591 |                 | (Vec2(_, _), Vec2(_, _), Vec2(_, _))
 592 |                 | (Vec3(_, _, _), Vec3(_, _, _), Vec3(_, _, _))
 593 |                 | (Vec4(_, _, _, _), Vec4(_, _, _, _), Vec4(_, _, _, _))
 594 |                 | (Float(_), Float(_), Vec2(_, _))
 595 |                 | (Float(_), Float(_), Vec3(_, _, _))
 596 |                 | (Float(_), Float(_), Vec4(_, _, _, _))
 597 |             => {
 598 |                 let t = x.sub(*self)?.div(edge1.sub(*self)?)?.clamp(Float(0.0), Float(1.0))?;
 599 |                 t.mult(t)?.mult(Float(3.0).sub(Float(2.0).mult(t)?)?)
 600 |             }
 601 |             (x, y, z) => Err(format!("Expected smoothstep(float, float, float), smoothstep(vec2, vec2, vec2), smoothstep(vec3, vec3, vec3), smoothstep(vec4, vec4, vec4), smoothstep(float, float, vec2), smoothstep(float, float, vec3), smoothstep(float, float, vec4), got smoothstep({:?}, {:?}, {:?})", x, y, z))
 602 |         }
 603 |     }
 604 | 
 605 |     pub fn length(&self) -> Result<Val, String> {
 606 |         let sum = match self.map(|x| x.powi(2)) {
 607 |             Float(x) => x,
 608 |             Vec2(x, y) => x + y,
 609 |             Vec3(x, y, z) => x + y + z,
 610 |             Vec4(x, y, z, w) => x + y + z + w,
 611 | 
 612 |             x => return Err(format!("Expected length(float), length(vec2), length(vec3), length(vec4), got length({:?})", x))
 613 |         };
 614 | 
 615 |         Ok(Float(sum.sqrt()))
 616 |     }
 617 | 
 618 |     pub fn dist(&self, o: Self) -> Result<Val, String> {
 619 |         match (self, o) {
 620 |             (Float(_), Float(_))
 621 |                 | (Vec2(_, _), Vec2(_, _))
 622 |                 | (Vec3(_, _, _), Vec3(_, _, _))
 623 |                 | (Vec4(_, _, _, _), Vec4(_, _, _, _))
 624 |             => self.zipmap(o, |x, y| x - y)?.length(),
 625 |             _ => Err(format!("Expected dist(float, float), dist(vec2, vec2), dist(vec3, vec3), dist(vec4, vec4), got dist({:?}, {:?})", self, o))
 626 |         }
 627 |     }
 628 | 
 629 |     pub fn cross(&self, o: Self) -> Result<Val, String> {
 630 |         match (self, o) {
 631 |             (Vec3(x0, y0, z0), Vec3(x1, y1, z1)) => Ok(Vec3(
 632 |                 y0 * z1 - z0 * y1,
 633 |                 z0 * x1 - x0 * z1,
 634 |                 x0 * y1 - y0 * x1,
 635 |             )),
 636 |             _ => Err(format!(
 637 |                 "Expected cross(vec3, vec3), got cross({:?}, {:?})",
 638 |                 self, o
 639 |             )),
 640 |         }
 641 |     }
 642 | 
 643 |     pub fn norm(&self) -> Result<Val, String> {
 644 |         self.zipmap(self.length()?, |x, len| x / len)
 645 |     }
 646 | }
 647 | 
 648 | #[derive(Debug, Clone, Copy, PartialEq)]
 649 | pub enum BuiltIn {
 650 |     // image utilities
 651 |     Sample,
 652 | 
 653 |     // vector utilities
 654 |     Dist,
 655 |     Radians,
 656 |     Degrees,
 657 |     Sin,
 658 |     Cos,
 659 |     Tan,
 660 |     Asin,
 661 |     Acos,
 662 |     Atan,
 663 |     Pow,
 664 |     Exp,
 665 |     Log,
 666 |     Sqrt,
 667 |     InverseSqrt,
 668 |     Abs,
 669 |     Sign,
 670 |     Floor,
 671 |     Ceil,
 672 |     Fract,
 673 |     Mod,
 674 |     Min,
 675 |     Max,
 676 |     Clamp,
 677 |     Mix,
 678 |     Step,
 679 |     Length,
 680 |     Dot,
 681 |     Cross,
 682 |     Norm,
 683 | 
 684 |     // matrix utilities
 685 |     Mat2,
 686 |     Mat3,
 687 |     Mat4,
 688 |     RotateX,
 689 |     RotateY,
 690 |     RotateZ,
 691 |     Rotate,
 692 |     Scale,
 693 |     Translate,
 694 |     Ortho,
 695 |     LookAt,
 696 |     Perspective
 697 | }
 698 | 
 699 | #[derive(Debug, Clone, PartialEq)]
 700 | pub enum Ast {
 701 |     V(Val),
 702 |     Repeat(f32, Box<SrcAst>),
 703 |     While(Box<SrcAst>, f32, Box<SrcAst>),
 704 |     Assign(Spur, Box<SrcAst>),
 705 |     Block(Vec<SrcAst>),
 706 |     VecLiteral(
 707 |         Box<SrcAst>,
 708 |         Box<SrcAst>,
 709 |         Option<Box<SrcAst>>,
 710 |         Option<Box<SrcAst>>,
 711 |     ),
 712 |     VecRepeated(Box<SrcAst>, Box<SrcAst>),
 713 |     VecAccess(Box<SrcAst>, Swizzle),
 714 |     MatAccess(Box<SrcAst>, Box<SrcAst>),
 715 |     Ident(Spur),
 716 |     Return(Box<SrcAst>),
 717 |     Give(Box<SrcAst>),
 718 |     BinOp(Box<SrcAst>, Op, Box<SrcAst>),
 719 |     If {
 720 |         cond: Box<SrcAst>,
 721 |         true_ret: Box<SrcAst>,
 722 |         false_ret: Box<SrcAst>,
 723 |     },
 724 |     Call(BuiltIn, Vec<SrcAst>),
 725 | }
 726 | 
 727 | #[derive(Debug, Clone, PartialEq)]
 728 | pub struct SrcAst {
 729 |     pub ast: Ast,
 730 |     pub line: usize,
 731 | }
 732 | impl SrcAst {
 733 |     //! had to resist an overwhelming urge to name this "mapro"
 734 |     pub fn map<F: Fn(SrcAst) -> SrcAst>(self, f: &F) -> Self {
 735 |         use Ast::*;
 736 |         let map = |sa: SrcAst| sa.map(f);
 737 |         let bmap = |sa: Box<SrcAst>| Box::new(sa.map(f));
 738 | 
 739 |         let SrcAst { ast, line } = f(self);
 740 |         SrcAst {
 741 |             line,
 742 |             ast: match ast {
 743 |                 V(v) => V(v),
 744 |                 Assign(s, t) => Assign(s, bmap(t)),
 745 |                 While(cond, n, block) => While(bmap(cond), n, bmap(block)),
 746 |                 Repeat(n, x) => Repeat(n, bmap(x)),
 747 |                 Block(nodes) => Block(nodes.into_iter().map(map).collect()),
 748 |                 VecLiteral(x, y, z, w) => {
 749 |                     VecLiteral(bmap(x), bmap(y), z.map(|z| bmap(z)), w.map(|w| bmap(w)))
 750 |                 }
 751 |                 VecRepeated(l, n) => VecRepeated(bmap(l), bmap(n)),
 752 |                 VecAccess(v, s) => VecAccess(bmap(v), s),
 753 |                 MatAccess(v, f) => MatAccess(bmap(v), bmap(f)),
 754 |                 Ident(s) => Ident(s),
 755 |                 Return(expr) => Return(bmap(expr)),
 756 |                 Give(expr) => Give(bmap(expr)),
 757 |                 BinOp(lhs, op, rhs) => BinOp(bmap(lhs), op, bmap(rhs)),
 758 |                 If {
 759 |                     cond,
 760 |                     true_ret: t,
 761 |                     false_ret: f,
 762 |                 } => If {
 763 |                     cond: bmap(cond),
 764 |                     true_ret: bmap(t),
 765 |                     false_ret: bmap(f),
 766 |                 },
 767 |                 Call(bi, args) => Call(bi, args.into_iter().map(map).collect()),
 768 |             },
 769 |         }
 770 |     }
 771 | }
 772 | 
 773 | impl SrcAst {
 774 |     pub fn new(ast: Ast, line: usize) -> SrcAst {
 775 |         SrcAst { ast, line }
 776 |     }
 777 | }
 778 | 
 779 | #[derive(Debug, Clone)]
 780 | pub struct Sampler<'a> {
 781 |     image: &'a ImageBuffer<Rgba<u8>, Vec<u8>>,
 782 |     width: u32,
 783 |     height: u32
 784 | }
 785 | 
 786 | impl<'a> Sampler<'a> {
 787 |     pub fn from(image: &'a ImageBuffer<Rgba<u8>, Vec<u8>>) -> Sampler {
 788 |         let (width, height) = image.dimensions();
 789 | 
 790 |         Sampler { image, width, height }
 791 |     }
 792 | 
 793 |     pub fn sample(&self, x: f32, y: f32) -> Val {
 794 |         if x > 1.0 || x < 0.0 {
 795 |             return Vec4(0.0, 0.0, 0.0, 0.0);
 796 |         }
 797 |         
 798 |         if y > 1.0 || y < 0.0 {
 799 |             return Vec4(0.0, 0.0, 0.0, 0.0);
 800 |         }
 801 | 
 802 |         let [r, g, b, a] = self.image.get_pixel((x * ((self.width - 1) as f32)) as u32, (y * ((self.height - 1) as f32)) as u32).0;
 803 | 
 804 |         Vec4(r as f32 / 255.0, g as f32 / 255.0,  b as f32 / 255.0, a as f32 / 255.0)
 805 |     }
 806 | }
 807 | 
 808 | #[derive(Default, Debug, Clone)]
 809 | pub struct Env<'a> {
 810 |     vars: HashMap<Spur, Val>,
 811 |     sampler: Option<Sampler<'a>>,
 812 |     pub ret: Option<Val>,
 813 |     parent: Option<Box<Env<'a>>>,
 814 | }
 815 | 
 816 | impl<'a> Env<'a> {
 817 |     pub fn with_sampler(sampler: Sampler) -> Env {
 818 |         let mut env = Env::default();
 819 | 
 820 |         env.sampler = Some(sampler);
 821 | 
 822 |         env
 823 |     }
 824 | 
 825 |     fn child(self) -> Self {
 826 |         Self {
 827 |             vars: Default::default(),
 828 |             sampler: self.sampler.clone(),
 829 |             parent: Some(Box::new(self)),
 830 |             ret: None,
 831 |         }
 832 |     }
 833 | 
 834 |     fn get(&self, ident: Spur) -> Option<Val> {
 835 |         self.vars
 836 |             .get(&ident)
 837 |             .map(|x| *x) // .as_deref()
 838 |             .or_else(|| self.parent.as_ref().and_then(|p| p.get(ident)))
 839 |     }
 840 | 
 841 |     pub fn set(&mut self, ident: Spur, to: Val) {
 842 |         if self.vars.contains_key(&ident) || self.get(ident).is_none() {
 843 |             self.vars.insert(ident, to);
 844 |         } else if let Some(p) = self.parent.as_mut() {
 845 |             p.set(ident, to);
 846 |         }
 847 |     }
 848 | 
 849 |     fn return_val(&mut self, val: Val) {
 850 |         self.ret = Some(val);
 851 |         if let Some(p) = self.parent.as_mut() {
 852 |             p.return_val(val)
 853 |         }
 854 |     }
 855 | }
 856 | 
 857 | pub struct EvalRet<'a> {
 858 |     pub env: Env<'a>,
 859 |     pub val: Option<Val>,
 860 |     give: Option<Val>,
 861 | }
 862 | 
 863 | struct ERVal<'a> {
 864 |     env: Env<'a>,
 865 |     val: Val,
 866 | }
 867 | 
 868 | impl<'a> EvalRet<'a> {
 869 |     fn new(env: Env<'a>) -> Self {
 870 |         Self {
 871 |             env,
 872 |             val: None,
 873 |             give: None,
 874 |         }
 875 |     }
 876 | 
 877 |     fn with_val(self, val: Option<Val>) -> Self {
 878 |         Self { val, ..self }
 879 |     }
 880 | 
 881 |     fn with_give(self, give: Val) -> Self {
 882 |         Self {
 883 |             give: Some(give),
 884 |             ..self
 885 |         }
 886 |     }
 887 | 
 888 |     fn needs_val(self) -> ERVal<'a> {
 889 |         ERVal {
 890 |             env: self.env,
 891 |             val: need_val(self.val),
 892 |         }
 893 |     }
 894 | }
 895 | 
 896 | fn need_val(v: Option<Val>) -> Val {
 897 |     v.expect("context requires associated expression to return a value")
 898 | }
 899 | 
 900 | pub fn is_const(SrcAst { ast, .. }: &SrcAst) -> bool {
 901 |     use Ast::*;
 902 | 
 903 |     match ast {
 904 |         &V(_) => true,
 905 |         Assign(_, _) => false,
 906 |         While(cond, _, block) => is_const(cond) && is_const(block),
 907 |         Repeat(_, e) => is_const(e),
 908 |         Give(_) => false,
 909 |         Block(nodes) => matches!(
 910 |             nodes.iter().skip_while(|x| is_const(x)).next(),
 911 |             Some(SrcAst{ ast: Give(x), .. }) if is_const(x)
 912 |         ),
 913 |         VecLiteral(x, y, z, w) => {
 914 |             is_const(x)
 915 |                 && is_const(y)
 916 |                 && z.as_deref().map(is_const).unwrap_or(true)
 917 |                 && w.as_deref().map(is_const).unwrap_or(true)
 918 |         }
 919 |         VecRepeated(l, n) => is_const(l) && is_const(n),
 920 |         VecAccess(v, _) => is_const(v),
 921 |         MatAccess(v, x) => is_const(v) && is_const(x),
 922 |         Ident(_) => false,
 923 |         Return(_) => false,
 924 |         BinOp(lhs, _, rhs) => is_const(lhs) && is_const(rhs),
 925 |         If {
 926 |             cond,
 927 |             true_ret: t,
 928 |             false_ret: f,
 929 |         } => is_const(cond) && is_const(t) && is_const(f),
 930 |         Call(_, args) => args.into_iter().all(is_const),
 931 |     }
 932 | }
 933 | 
 934 | pub fn fold(SrcAst { ast, .. }: &SrcAst) -> Option<Val> {
 935 |     use Ast::*;
 936 | 
 937 |     match ast {
 938 |         &V(v) => Some(v),
 939 |         Assign(_, _) => None,
 940 |         Block(nodes) => nodes
 941 |             .iter()
 942 |             .fold(Some(None::<Val>), |a, x| match (a, &x.ast) {
 943 |                 (Some(_), Give(g)) => Some(fold(g)),
 944 |                 _ => a.filter(|_| fold(x).is_some()),
 945 |             })
 946 |             .flatten(),
 947 |         VecLiteral(x, y, m_z, m_w) => Some(
 948 |             match (
 949 |                 fold(x).and_then(|v| v.float()),
 950 |                 fold(y).and_then(|v| v.float()),
 951 |                 m_z.as_ref().map(|z| fold(z).and_then(|v| v.float())),
 952 |                 m_w.as_ref().map(|w| fold(w).and_then(|v| v.float())),
 953 |             ) {
 954 |                 (Some(x), Some(y), Some(Some(z)), Some(Some(w))) => Val::Vec4(x, y, z, w),
 955 |                 (Some(x), Some(y), Some(Some(z)), None) => Val::Vec3(x, y, z),
 956 |                 (Some(x), Some(y), None, None) => Val::Vec2(x, y),
 957 |                 _ => return None,
 958 |             },
 959 |         ),
 960 |         _ => None, /*
 961 |                    VecRepeated(Box<SrcAst>, Box<SrcAst>),
 962 |                    VecAccess(Box<SrcAst>, Swizzle),
 963 |                    Ident(Spur),
 964 |                    Return(Box<SrcAst>),
 965 |                    Give(Box<SrcAst>),
 966 |                    BinOp(Box<SrcAst>, Op, Box<SrcAst>),
 967 |                    If {
 968 |                        cond: Box<SrcAst>,
 969 |                        true_ret: Box<SrcAst>,
 970 |                        false_ret: Box<SrcAst>,
 971 |                    },
 972 |                    Call(BuiltIn, Vec<SrcAst>), */
 973 |     }
 974 | }
 975 | 
 976 | macro_rules! builtin_one_arg {
 977 |     ($op:path, $function:expr, $len:ident, $line:ident, $vals:ident, $env:ident) => {{
 978 |         if $len != 1 {
 979 |             report(
 980 |                 ErrorType::Runtime,
 981 |                 $line,
 982 |                 format!("Expected 1 input to {}(a), got {}", $function, $len),
 983 |             )
 984 |         }
 985 | 
 986 |         match $op(&$vals.pop().unwrap()) {
 987 |             Ok(result) =>  EvalRet::new($env).with_val(Some(result)),
 988 |             Err(error) => report(ErrorType::Runtime, $line, error)
 989 |         }
 990 |     }};
 991 | }
 992 | 
 993 | macro_rules! builtin_two_args {
 994 |     ($op:path, $function:expr, $len:ident, $line:ident, $vals:ident, $env:ident) => {{
 995 |         if $len != 2 {
 996 |             report(
 997 |                 ErrorType::Runtime,
 998 |                 $line,
 999 |                 format!("Expected 2 inputs to {}(a, b), got {}", $function, $len),
1000 |             )
1001 |         }
1002 | 
1003 |         let arg2 = $vals.pop().unwrap();
1004 |         let arg1 = $vals.pop().unwrap();
1005 | 
1006 |         EvalRet::new($env).with_val(Some(match $op(&arg1, arg2) {
1007 |             Ok(result) => result,
1008 |             Err(error) => report(ErrorType::Runtime, $line, error.as_str()),
1009 |         }))
1010 |     }};
1011 | }
1012 | 
1013 | macro_rules! builtin_three_args {
1014 |     ($op:path, $function:expr, $len:ident, $line:ident, $vals:ident, $env:ident) => {{
1015 |         if $len != 3 {
1016 |             report(
1017 |                 ErrorType::Runtime,
1018 |                 $line,
1019 |                 format!("Expected 3 inputs to {}(a, b, c), got {}", $function, $len),
1020 |             )
1021 |         }
1022 | 
1023 |         let arg3 = $vals.pop().unwrap();
1024 |         let arg2 = $vals.pop().unwrap();
1025 |         let arg1 = $vals.pop().unwrap();
1026 | 
1027 |         EvalRet::new($env).with_val(Some(match $op(&arg1, arg2, arg3) {
1028 |             Ok(result) => result,
1029 |             Err(error) => report(ErrorType::Runtime, $line, error.as_str()),
1030 |         }))
1031 |     }};
1032 | }
1033 | 
1034 | pub fn eval<'a>(&SrcAst { line, ref ast }: &SrcAst, e: Env<'a>, r: &Rodeo) -> EvalRet<'a> {
1035 |     use Ast::*;
1036 | 
1037 |     match ast {
1038 |         Repeat(times, block) => {
1039 |             if *times < 1.0 - f32::EPSILON {
1040 |                 report(ErrorType::Runtime, line, format!("Expected positive compile-time literal in repeat statement, got {}", times));
1041 |             }
1042 | 
1043 |             let t = *times as usize;
1044 | 
1045 |             if (times - (t as f32)).abs() > f32::EPSILON {
1046 |                 report(ErrorType::Runtime, line, format!("Expected whole number in repeat statement, got {}", times));
1047 |             }
1048 | 
1049 |             let mut ret = eval(block, e, &r);
1050 | 
1051 |             for _ in 0..t - 1 {
1052 |                 ret = eval(block, ret.env, &r);
1053 |             }
1054 | 
1055 |             ret
1056 |         }
1057 |         While(cond, times, block) => {
1058 |             if *times < 1.0 - f32::EPSILON {
1059 |                 report(ErrorType::Runtime, line, format!("Expected positive number of iterations in while statement, got {}", times));
1060 |             }
1061 | 
1062 |             let t = *times as usize;
1063 | 
1064 |             if (times - (t as f32)).abs() > f32::EPSILON {
1065 |                 report(ErrorType::Runtime, line, format!("Expected whole number of iterations in while statement, got {}", times));
1066 |             }
1067 | 
1068 |             let mut env = e;
1069 | 
1070 |             for _ in 0..t {
1071 |                 let ERVal { env: e, val } = eval(cond, env, r).needs_val();
1072 |                 env = e;
1073 | 
1074 |                 match val {
1075 |                     Float(condition) => if condition != 1.0 {
1076 |                         break
1077 |                     },
1078 |                     x => report(ErrorType::Runtime, line, format!("Expected condition to evaluate to float in while statement, got {:?}", x))
1079 |                 }
1080 | 
1081 |                 env = eval(block, env, r).env;
1082 |             }
1083 | 
1084 |             EvalRet::new(env)
1085 |        }
1086 |         &V(v) => EvalRet::new(e).with_val(Some(v)),
1087 |         Assign(i, to) => {
1088 |             let ERVal { mut env, val } = eval(&to, e, r).needs_val();
1089 |             env.set(*i, val);
1090 |             EvalRet::new(env).with_val(Some(val))
1091 |         }
1092 |         Block(nodes) => {
1093 |             let EvalRet { env, give, .. } =
1094 |                 nodes.iter().fold(EvalRet::new(e.child()), |acc, node| {
1095 |                     if acc.give.or(acc.env.ret).is_some() {
1096 |                         acc
1097 |                     } else {
1098 |                         eval(node, acc.env, r)
1099 |                     }
1100 |                 });
1101 |             EvalRet::new(*env.parent.unwrap()).with_val(env.ret.or(give))
1102 |         }
1103 |         VecRepeated(value, length) => {
1104 |             let ERVal { val: value, env } = eval(value, e, r).needs_val();
1105 |             let ERVal { val: length, env } = eval(length, env, r).needs_val();
1106 | 
1107 |             match (value, length) {
1108 |                 (Float(v), Float(l)) => match l as usize {
1109 |                     2 => EvalRet::new(env).with_val(Some(Val::Vec2(v, v))),
1110 |                     3 => EvalRet::new(env).with_val(Some(Val::Vec3(v, v, v))),
1111 |                     4 => EvalRet::new(env).with_val(Some(Val::Vec4(v, v, v, v))),
1112 |                     n => {
1113 |                         report(ErrorType::Runtime, line, format!("{} is an invalid vector length; must be 2 <= x <= 4", n))
1114 |                     }
1115 |                 },
1116 |                 _ => report(
1117 |                     ErrorType::Runtime,
1118 |                     line,
1119 |                     format!("Expected [float; float] for vector, got [{:?}, {:?}]", value, length),
1120 |                 ),
1121 |             }
1122 |         }
1123 |         VecLiteral(xast, yast, None, None) => {
1124 |             let ERVal { val: xval, env } = eval(&xast, e, r).needs_val();
1125 |             let ERVal { val: yval, env } = eval(&yast, env, r).needs_val();
1126 |             match (xval, yval) {
1127 |                 (Float(x), Float(y)) => EvalRet::new(env).with_val(Some(Val::Vec2(x, y))),
1128 |                 (x, y) => report(ErrorType::Runtime, line, format!("Expected [float, float] for vec2 initialization, got [{:?}, {:?}]", x, y))
1129 |             }
1130 |         }
1131 |         VecLiteral(_, _, None, Some(_)) => panic!("Unexpected vector initialization in AST (this is a bug in the interpreter)"),
1132 |         VecLiteral(xast, yast, Some(zast), None) => {
1133 |             let ERVal { val: xval, env } = eval(&xast, e, r).needs_val();
1134 |             let ERVal { val: yval, env } = eval(&yast, env, r).needs_val();
1135 |             let ERVal { val: zval, env } = eval(&zast, env, r).needs_val();
1136 |             match (xval, yval, zval) {
1137 |                 (Float(x), Float(y), Float(z)) => {
1138 |                     EvalRet::new(env).with_val(Some(Val::Vec3(x, y, z)))
1139 |                 }
1140 |                 (x, y, z) => report(ErrorType::Runtime, line, format!("Expected [float, float, float] for vec3 initialization, got [{:?}, {:?}, {:?}]", x, y, z))
1141 |             }
1142 |         }
1143 |         VecLiteral(xast, yast, Some(zast), Some(wast)) => {
1144 |             let ERVal { val: xval, env } = eval(&xast, e, r).needs_val();
1145 |             let ERVal { val: yval, env } = eval(&yast, env, r).needs_val();
1146 |             let ERVal { val: zval, env } = eval(&zast, env, r).needs_val();
1147 |             let ERVal { val: wval, env } = eval(&wast, env, r).needs_val();
1148 |             match (xval, yval, zval, wval) {
1149 |                 (Float(x), Float(y), Float(z), Float(w)) => {
1150 |                     EvalRet::new(env).with_val(Some(Val::Vec4(x, y, z, w)))
1151 |                 }
1152 |                 (x, y, z, w) => report(ErrorType::Runtime, line, format!("Expected [float, float, float, float] for vec4 initialization, got [{:?}, {:?}, {:?}, {:?}]", x, y, z, w))
1153 |             }
1154 |         }
1155 |         MatAccess(mat, row) => {
1156 |             let ERVal { env, val: matrix } = eval(mat, e, r).needs_val();
1157 |             let ERVal { env, val: access } = eval(row, env, r).needs_val();
1158 | 
1159 |             let access = if let Float(access) = access {
1160 |                 access
1161 |             } else {
1162 |                 report(
1163 |                     ErrorType::Runtime,
1164 |                     line,
1165 |                     format!("Expected float when indexing matrix, got {:?}", access),
1166 |                 )
1167 |             };
1168 | 
1169 |             let row = match matrix {
1170 |                 Mat2(_, _) => matrix.index_matrix(access as usize),
1171 |                 Mat3(_, _, _) => matrix.index_matrix(access as usize),
1172 |                 Mat4(_, _, _, _) => matrix.index_matrix(access as usize),
1173 |                 _ => report(
1174 |                     ErrorType::Runtime,
1175 |                     line,
1176 |                     format!("Expected matrix when indexing, got {:?}", matrix),
1177 |                 ),
1178 |             };
1179 | 
1180 |             match row {
1181 |                 Ok(row) => return EvalRet::new(env).with_val(Some(row)),
1182 |                 Err(error) => report(ErrorType::Runtime, line, error.as_str()),
1183 |             }
1184 |         }
1185 |         VecAccess(access_me, swiz) => {
1186 |             let ERVal { env, val } = eval(&access_me, e, r).needs_val();
1187 | 
1188 |             if let Val::Float(x) = val {
1189 |                 report(
1190 |                     ErrorType::Runtime,
1191 |                     line,
1192 |                     format!("Expected vector when swizzling, got {}", x),
1193 |                 );
1194 |             }
1195 | 
1196 |             EvalRet::new(env).with_val(Some(match *swiz {
1197 |                 Swizzle(x, None, None, None) => Val::Float(match val.get_field(x) {
1198 |                     Ok(result) => result,
1199 |                     Err(error) => report(ErrorType::Runtime, line, error)
1200 |                 }),
1201 |                 Swizzle(x, Some(y), None, None) => Val::Vec2(match val.get_field(x) {
1202 |                     Ok(result) => result,
1203 |                     Err(error) => report(ErrorType::Runtime, line, error)
1204 |                 }, match val.get_field(y) {
1205 |                     Ok(result) => result,
1206 |                     Err(error) => report(ErrorType::Runtime, line, error)
1207 |                 }),
1208 |                 Swizzle(x, Some(y), Some(z), None) => {
1209 |                     Val::Vec3(match val.get_field(x) {
1210 |                         Ok(result) => result,
1211 |                         Err(error) => report(ErrorType::Runtime, line, error)
1212 |                     }, match val.get_field(y) {
1213 |                         Ok(result) => result,
1214 |                         Err(error) => report(ErrorType::Runtime, line, error)
1215 |                     }, match val.get_field(z) {
1216 |                         Ok(result) => result,
1217 |                         Err(error) => report(ErrorType::Runtime, line, error)
1218 |                     })
1219 |                 }
1220 |                 Swizzle(x, Some(y), Some(z), Some(w)) => Val::Vec4(
1221 |                     match val.get_field(x) {
1222 |                         Ok(result) => result,
1223 |                         Err(error) => report(ErrorType::Runtime, line, error)
1224 |                     },
1225 |                     match val.get_field(y) {
1226 |                         Ok(result) => result,
1227 |                         Err(error) => report(ErrorType::Runtime, line, error)
1228 |                     },
1229 |                     match val.get_field(z) {
1230 |                         Ok(result) => result,
1231 |                         Err(error) => report(ErrorType::Runtime, line, error)
1232 |                     },
1233 |                     match val.get_field(w) {
1234 |                         Ok(result) => result,
1235 |                         Err(error) => report(ErrorType::Runtime, line, error)
1236 |                     },
1237 |                 ),
1238 |                 _ => report(ErrorType::Runtime, line, "Invalid swizzle"),
1239 |             }))
1240 |         }
1241 |         &Ident(i) => {
1242 |             if let Some(val) = e.get(i) {
1243 |                 return EvalRet::new(e).with_val(Some(val));
1244 |             }
1245 | 
1246 |             report(
1247 |                 ErrorType::Runtime,
1248 |                 line,
1249 |                 format!("Couldn't resolve identifier '{}'", r.resolve(&i)),
1250 |             )
1251 |         }
1252 |         Return(v) => {
1253 |             let ERVal { mut env, val } = eval(&v, e, r).needs_val();
1254 |             env.return_val(val);
1255 |             EvalRet::new(env)
1256 |         }
1257 |         Give(g) => {
1258 |             let ERVal { env, val } = eval(&g, e, r).needs_val();
1259 |             EvalRet::new(env).with_give(val)
1260 |         }
1261 |         BinOp(lhs, op, rhs) => {
1262 |             let ERVal { env, val: lval } = eval(&lhs, e, r).needs_val();
1263 |             let ERVal { env, val: rval } = eval(&rhs, env, r).needs_val();
1264 | 
1265 |             use Val::*;
1266 |             EvalRet::new(env).with_val(Some(match (lval, op, rval) {
1267 |                 (_, Op::Sub, _) => match lval.sub(rval) {
1268 |                     Ok(result) => result,
1269 |                     Err(error) => report(ErrorType::Runtime, line, error)
1270 |                 },
1271 |                 (_, Op::Add, _) => match lval.add(rval) {
1272 |                     Ok(result) => result,
1273 |                     Err(error) => report(ErrorType::Runtime, line, error)
1274 |                 },
1275 |                 (_, Op::Mul, _) => match lval.mult(rval) {
1276 |                     Ok(result) => result,
1277 |                     Err(error) => report(ErrorType::Runtime, line, error)
1278 |                 }
1279 |                 (_, Op::Div, _) => match lval.div(rval) {
1280 |                     Ok(result) => result,
1281 |                     Err(error) => report(ErrorType::Runtime, line, error)
1282 |                 },
1283 |                 (Float(l), Op::More, Float(r)) => Float((l > r) as i32 as f32),
1284 |                 (Float(l), Op::Less, Float(r)) => Float((l < r) as i32 as f32),
1285 |                 (Float(l), Op::MoreEq, Float(r)) => Float((l >= r) as i32 as f32),
1286 |                 (Float(l), Op::LessEq, Float(r)) => Float((l <= r) as i32 as f32),
1287 |                 (Float(l), Op::Equal, Float(r)) => Float(if l == r { 1.0 } else { 0.0 }),
1288 |                 (Float(l), Op::NotEqual, Float(r)) => Float(if l != r { 1.0 } else { 0.0 }),
1289 |                 _ => report(
1290 |                     ErrorType::Runtime,
1291 |                     line,
1292 |                     format!("Unexpected scalar/vector binary operation relationship, got {:#?} {:#?} {:#?}", lval, op, rval),
1293 |                 )
1294 |             }))
1295 |         }
1296 |         If {
1297 |             cond,
1298 |             true_ret,
1299 |             false_ret,
1300 |         } => {
1301 |             let ERVal { env, val: condval } = eval(&cond, e, r).needs_val();
1302 |             match condval {
1303 |                 Val::Float(f) if f == 1.0 => eval(&true_ret, env, r),
1304 |                 Val::Float(_) => eval(&false_ret, env, r),
1305 |                 _ => report(
1306 |                     ErrorType::Runtime,
1307 |                     line,
1308 |                     format!(
1309 |                         "Expected scalar conditional in if expression, got {:#?}",
1310 |                         condval
1311 |                     )
1312 |                     .as_str(),
1313 |                 ),
1314 |             }
1315 |         }
1316 |         Call(builtin, args) => {
1317 |             let len = args.len();
1318 |             let (env, mut vals) =
1319 |                 args.iter()
1320 |                     .fold((e, Vec::with_capacity(len)), |(env, mut vals), arg| {
1321 |                         let ERVal { env, val } = eval(arg, env, r).needs_val();
1322 |                         vals.push(val);
1323 |                         (env, vals)
1324 |                     });
1325 | 
1326 |             match *builtin {
1327 |                 BuiltIn::Mat2 => {
1328 |                     if len != 2 {
1329 |                         report(
1330 |                             ErrorType::Runtime,
1331 |                             line,
1332 |                             format!("Expected 2 inputs to mat2(vec2, vec2), got {}", len),
1333 |                         );
1334 |                     }
1335 | 
1336 |                     let arg2 = vals.pop().unwrap();
1337 |                     let arg1 = vals.pop().unwrap();
1338 | 
1339 |                     let mat = match (arg1, arg2) {
1340 |                         (Vec2(x0, y0), Vec2(x1, y1)) => Mat2([x0, y0], [x1, y1]),
1341 |                         (x, y) => report(
1342 |                             ErrorType::Runtime,
1343 |                             line,
1344 |                             format!("Expected mat2(vec2, vec2), got mat2({:?}, {:?})", x, y)
1345 |                                 .as_str(),
1346 |                         ),
1347 |                     };
1348 | 
1349 |                     EvalRet::new(env).with_val(Some(mat))
1350 |                 }
1351 |                 BuiltIn::Mat3 => {
1352 |                     if len != 3 {
1353 |                         report(
1354 |                             ErrorType::Runtime,
1355 |                             line,
1356 |                             format!("Expected 3 inputs to mat3(vec3, vec3, vec3), got {}", len)
1357 |                                 .as_str(),
1358 |                         );
1359 |                     }
1360 | 
1361 |                     let arg3 = vals.pop().unwrap();
1362 |                     let arg2 = vals.pop().unwrap();
1363 |                     let arg1 = vals.pop().unwrap();
1364 | 
1365 |                     let mat = match (arg1, arg2, arg3) {
1366 |                         (Vec3(x0, y0, z0), Vec3(x1, y1, z1), Vec3(x2, y2, z2)) => {
1367 |                             Mat3([x0, y0, z0], [x1, y1, z1], [x2, y2, z2])
1368 |                         }
1369 |                         (x, y, z) => report(
1370 |                             ErrorType::Runtime,
1371 |                             line,
1372 |                             format!(
1373 |                                 "Expected mat3(vec3, vec3, vec3), got mat3({:?}, {:?}, {:?})",
1374 |                                 x, y, z
1375 |                             )
1376 |                             .as_str(),
1377 |                         ),
1378 |                     };
1379 | 
1380 |                     EvalRet::new(env).with_val(Some(mat))
1381 |                 }
1382 |                 BuiltIn::Mat4 => {
1383 |                     if len != 4 {
1384 |                         report(
1385 |                             ErrorType::Runtime,
1386 |                             line,
1387 |                             format!(
1388 |                                 "Expected 4 inputs to mat4(vec4, vec4, vec4, vec4), got {}",
1389 |                                 len
1390 |                             )
1391 |                             .as_str(),
1392 |                         );
1393 |                     }
1394 | 
1395 |                     let arg4 = vals.pop().unwrap();
1396 |                     let arg3 = vals.pop().unwrap();
1397 |                     let arg2 = vals.pop().unwrap();
1398 |                     let arg1 = vals.pop().unwrap();
1399 | 
1400 |                     let mat = match (arg1, arg2, arg3, arg4) {
1401 |                         (Vec4(x0, y0, z0, w0), Vec4(x1, y1, z1, w1), Vec4(x2, y2, z2, w2), Vec4(x3, y3, z3, w3)) => Mat4([x0, y0, z0, w0], [x1, y1, z1, w1], [x2, y2, z2, w2], [x3, y3, z3, w3]),
1402 |                         (x, y, z, w) => report(ErrorType::Runtime, line, format!("Expected mat4(vec4, vec4, vec4, vec4), got mat4({:?}, {:?}, {:?}, {:?})", x, y, z, w))
1403 |                     };
1404 | 
1405 |                     EvalRet::new(env).with_val(Some(mat))
1406 |                 }
1407 |                 BuiltIn::Sample => {
1408 |                     if len != 1 {
1409 |                         report(
1410 |                             ErrorType::Runtime,
1411 |                             line,
1412 |                             format!(
1413 |                                 "Expected 1 input to sample(vec2), got {}",
1414 |                                 len
1415 |                             )
1416 |                             .as_str(),
1417 |                         );
1418 |                     }
1419 | 
1420 |                     let pixel = match (vals.pop().unwrap(), &env.sampler) {
1421 |                         (Vec2(x, y), Some(sampler)) => sampler.sample(x, y),
1422 |                         (x, _) => report(ErrorType::Runtime, line, format!("Expected sample(vec2), got sample({:?}", x))
1423 |                     };
1424 | 
1425 |                     EvalRet::new(env).with_val(Some(pixel))
1426 |                 }
1427 |                 BuiltIn::Dist => {
1428 |                     builtin_two_args!(Val::dist, "dist", len, line, vals, env)
1429 |                 }
1430 |                 BuiltIn::Pow => {
1431 |                     builtin_two_args!(Val::pow, "pow", len, line, vals, env)
1432 |                 }
1433 |                 BuiltIn::Sin => {
1434 |                     builtin_one_arg!(Val::sin, "sin", len, line, vals, env)
1435 |                 }
1436 |                 BuiltIn::Cos => {
1437 |                     builtin_one_arg!(Val::cos, "cos", len, line, vals, env)
1438 |                 }
1439 |                 BuiltIn::Tan => {
1440 |                     builtin_one_arg!(Val::tan, "tan", len, line, vals, env)
1441 |                 }
1442 |                 BuiltIn::Asin => {
1443 |                     builtin_one_arg!(Val::asin, "asin", len, line, vals, env)
1444 |                 }
1445 |                 BuiltIn::Acos => {
1446 |                     builtin_one_arg!(Val::acos, "acos", len, line, vals, env)
1447 |                 }
1448 |                 BuiltIn::Atan => {
1449 |                     builtin_one_arg!(Val::atan, "atan", len, line, vals, env)
1450 |                 }
1451 |                 BuiltIn::Exp => {
1452 |                     builtin_one_arg!(Val::exp, "exp", len, line, vals, env)
1453 |                 }
1454 |                 BuiltIn::Log => {
1455 |                     builtin_one_arg!(Val::log, "log", len, line, vals, env)
1456 |                 }
1457 |                 BuiltIn::Sqrt => {
1458 |                     builtin_one_arg!(Val::sqrt, "sqrt", len, line, vals, env)
1459 |                 }
1460 |                 BuiltIn::InverseSqrt => {
1461 |                     builtin_one_arg!(Val::invsqrt, "invsqrt", len, line, vals, env)
1462 |                 }
1463 |                 BuiltIn::Abs => {
1464 |                     builtin_one_arg!(Val::abs, "abs", len, line, vals, env)
1465 |                 }
1466 |                 BuiltIn::Sign => {
1467 |                     builtin_one_arg!(Val::sign, "sign", len, line, vals, env)
1468 |                 }
1469 |                 BuiltIn::Floor => {
1470 |                     builtin_one_arg!(Val::floor, "floor", len, line, vals, env)
1471 |                 }
1472 |                 BuiltIn::Ceil => {
1473 |                     builtin_one_arg!(Val::ceil, "ceil", len, line, vals, env)
1474 |                 }
1475 |                 BuiltIn::Fract => {
1476 |                     builtin_one_arg!(Val::fract, "fract", len, line, vals, env)
1477 |                 }
1478 |                 BuiltIn::Mod => {
1479 |                     builtin_two_args!(Val::modulo, "mod", len, line, vals, env)
1480 |                 }
1481 |                 BuiltIn::Min => {
1482 |                     builtin_two_args!(Val::min, "min", len, line, vals, env)
1483 |                 }
1484 |                 BuiltIn::Max => {
1485 |                     builtin_two_args!(Val::max, "max", len, line, vals, env)
1486 |                 }
1487 |                 BuiltIn::Clamp => {
1488 |                     builtin_three_args!(Val::clamp, "clamp", len, line, vals, env)
1489 |                 }
1490 |                 BuiltIn::Mix => {
1491 |                     builtin_three_args!(Val::mix, "mix", len, line, vals, env)
1492 |                 }
1493 |                 BuiltIn::Step => {
1494 |                     builtin_two_args!(Val::step, "step", len, line, vals, env)
1495 |                 }
1496 |                 BuiltIn::Length => {
1497 |                     builtin_one_arg!(Val::length, "length", len, line, vals, env)
1498 |                 }
1499 |                 BuiltIn::Dot => {
1500 |                     builtin_two_args!(Val::dot, "dot", len, line, vals, env)
1501 |                 }
1502 |                 BuiltIn::Cross => {
1503 |                     builtin_two_args!(Val::cross, "cross", len, line, vals, env)
1504 |                 }
1505 |                 BuiltIn::Norm => {
1506 |                     builtin_one_arg!(Val::norm, "norm", len, line, vals, env)
1507 |                 }
1508 |                 BuiltIn::Radians => {
1509 |                     builtin_one_arg!(Val::radians, "radians", len, line, vals, env)
1510 |                 }
1511 |                 BuiltIn::Degrees => {
1512 |                     builtin_one_arg!(Val::degrees, "degrees", len, line, vals, env)
1513 |                 }
1514 |                 BuiltIn::RotateX => {
1515 |                     if len != 1 {
1516 |                         report(ErrorType::Runtime, line, format!("Expected 1 input to rotate_x(a), got {}", len));
1517 |                     }
1518 | 
1519 |                     match vals.pop().unwrap() {
1520 |                         Float(radians) => EvalRet::new(env).with_val(Some(Val::rotate_x(radians))),
1521 |                         x => report(ErrorType::Runtime, line, format!("Expected rotate_x(float), got rotate_x({:?})", x))
1522 |                     }
1523 |                 }
1524 |                 BuiltIn::RotateY => {
1525 |                     if len != 1 {
1526 |                         report(ErrorType::Runtime, line, format!("Expected 1 input to rotate_y(a), got {}", len));
1527 |                     }
1528 | 
1529 |                     match vals.pop().unwrap() {
1530 |                         Float(radians) => EvalRet::new(env).with_val(Some(Val::rotate_y(radians))),
1531 |                         x => report(ErrorType::Runtime, line, format!("Expected rotate_y(float), got rotate_y({:?})", x))
1532 |                     }
1533 |                 },
1534 |                 BuiltIn::RotateZ => {
1535 |                     if len != 1 {
1536 |                         report(ErrorType::Runtime, line, format!("Expected 1 input to rotate_z(a), got {}", len));
1537 |                     }
1538 | 
1539 |                     match vals.pop().unwrap() {
1540 |                         Float(radians) => EvalRet::new(env).with_val(Some(Val::rotate_z(radians))),
1541 |                         x => report(ErrorType::Runtime, line, format!("Expected rotate_z(float), got rotate_z({:?})", x))
1542 |                     }
1543 |                 },
1544 |                 BuiltIn::Rotate => {
1545 |                     if len != 3 {
1546 |                         report(ErrorType::Runtime, line, format!("Expected 3 inputs to rotate(a, b, c), got {}", len));
1547 |                     }
1548 | 
1549 |                     let arg3 = vals.pop().unwrap();
1550 |                     let arg2 = vals.pop().unwrap();
1551 |                     let arg1 = vals.pop().unwrap();
1552 | 
1553 |                     match (arg1, arg2, arg3) {
1554 |                         (Float(yaw), Float(pitch), Float(roll)) => EvalRet::new(env).with_val(Some(Val::rotate(yaw, pitch, roll))),
1555 |                         (x, y, z) => report(ErrorType::Runtime, line, format!("Expected rotate(float, float, float), got rotate({:?}, {:?}, {:?})", x, y, z))
1556 |                     }
1557 |                 },
1558 |                 BuiltIn::Scale => {
1559 |                     if len != 1 {
1560 |                         report(ErrorType::Runtime, line, format!("Expected 1 input to scale(a), got {}", len));
1561 |                     }
1562 | 
1563 |                     match vals.pop().unwrap() {
1564 |                         Float(s) => EvalRet::new(env).with_val(Some(Val::scale(s))),
1565 |                         x => report(ErrorType::Runtime, line, format!("Expected scale(float), got scale({:?})", x))
1566 |                     }
1567 |                 }
1568 |                 BuiltIn::Translate => {
1569 |                     if len != 3 {
1570 |                         report(ErrorType::Runtime, line, format!("Expected 3 inputs to translate(a, b, c), got {}", len));
1571 |                     }
1572 | 
1573 |                     let arg3 = vals.pop().unwrap();
1574 |                     let arg2 = vals.pop().unwrap();
1575 |                     let arg1 = vals.pop().unwrap();
1576 | 
1577 |                     match (arg1, arg2, arg3) {
1578 |                         (Float(x), Float(y), Float(z)) => EvalRet::new(env).with_val(Some(Val::translate(x, y, z))),
1579 |                         (x, y, z) => report(ErrorType::Runtime, line, format!("Expected translate(float, float, float), got translate({:?}, {:?}, {:?})", x, y, z))
1580 |                     }
1581 |                 },
1582 |                 BuiltIn::Ortho => {
1583 |                     if len != 6 {
1584 |                         report(ErrorType::Runtime, line, format!("Expected 6 inputs to ortho(a, b, c, d, e, f), got {}", len));
1585 |                     }
1586 | 
1587 |                     let arg6 = vals.pop().unwrap();
1588 |                     let arg5 = vals.pop().unwrap();
1589 |                     let arg4 = vals.pop().unwrap();
1590 |                     let arg3 = vals.pop().unwrap();
1591 |                     let arg2 = vals.pop().unwrap();
1592 |                     let arg1 = vals.pop().unwrap();
1593 | 
1594 |                     match (arg1, arg2, arg3, arg4, arg5, arg6) {
1595 |                         (Float(near), Float(far), Float(left), Float(right), Float(top), Float(bottom)) => EvalRet::new(env).with_val(Some(Val::ortho(near, far, left, right, top, bottom))),
1596 |                         (x, y, z, w, v, u) => report(ErrorType::Runtime, line, format!("Expected ortho(float, float, float, float, float, float), got ortho({:?}, {:?}, {:?}, {:?}, {:?}, {:?})", x, y, z, w, v, u))
1597 |                     }
1598 |                 }
1599 |                 BuiltIn::LookAt => {
1600 |                     builtin_two_args!(Val::lookat, "lookat", len, line, vals, env)
1601 |                }
1602 |                 BuiltIn::Perspective => {
1603 |                     if len != 3 {
1604 |                         report(ErrorType::Runtime, line, format!("Expected 3 inputs to perspective(a, b, c), got {}", len));
1605 |                     }
1606 | 
1607 |                     let arg3 = vals.pop().unwrap();
1608 |                     let arg2 = vals.pop().unwrap();
1609 |                     let arg1 = vals.pop().unwrap();
1610 |     
1611 |                     match (arg1, arg2, arg3) {
1612 |                         (Float(fov), Float(near), Float(far)) => EvalRet::new(env).with_val(Some(Val::perspective(fov, near, far))),
1613 |                         (x, y, z) => report(ErrorType::Runtime, line, format!("Expected perspective(float, float, float), got perspective({:?}, {:?}, {:?})", x, y, z))
1614 |                     }
1615 |                 }
1616 |             }
1617 |         }
1618 |     }
1619 | }
1620 | 
1621 | #[test]
1622 | fn constant_folding() {
1623 |     assert_eq!(
1624 |         crate::string_to_ast("return [1 + 2; 4]").1.ast,
1625 |         crate::string_to_ast("return [3; 4]").1.ast,
1626 |     );
1627 | 
1628 |     assert_eq!(
1629 |         crate::string_to_ast("return { give [1 + 2; 4] }").1.ast,
1630 |         crate::string_to_ast("return [3; 4]").1.ast,
1631 |     );
1632 | }
1633 | 


--------------------------------------------------------------------------------
/bml/src/lib.rs:
--------------------------------------------------------------------------------
 1 | pub mod ast;
 2 | pub mod logger;
 3 | pub mod r#macro;
 4 | pub mod parser;
 5 | pub mod preprocessor;
 6 | pub mod scanner;
 7 | pub mod token;
 8 | pub mod token_type;
 9 | pub use parser::Parser;
10 | pub use preprocessor::PreProcessor;
11 | pub use scanner::Scanner;
12 | 
13 | pub fn string_to_ast<S: AsRef<str>>(string: S) -> (lasso::Rodeo, ast::SrcAst) {
14 |     let raw = Scanner::from(string.as_ref().to_owned()).scan();
15 |     let expanded = PreProcessor::from(raw).process();
16 | 
17 |     // for i in 0..expanded.len() {
18 |     //     let token = &expanded[i];
19 | 
20 |     //     match expanded.get(i - 1) {
21 |     //         Some(t) if t.line != token.line => println!(),
22 |     //         _ => {}
23 |     //     }
24 | 
25 |     //     print!("{} ", token.lexeme);
26 |     // }
27 | 
28 |     let (ro, ast) = Parser::from(&expanded).parse();
29 |     let const_ro = lasso::Rodeo::new();
30 | 
31 |     (
32 |         ro,
33 |         ast.map(&|sa| match ast::is_const(&sa) {
34 |             true => ast::SrcAst {
35 |                 ast: ast::Ast::V(ast::eval(&sa, ast::Env::default(), &const_ro).val.unwrap()),
36 |                 line: sa.line,
37 |             },
38 |             _ => sa,
39 |         }),
40 |     )
41 | }
42 | 


--------------------------------------------------------------------------------
/bml/src/logger.rs:
--------------------------------------------------------------------------------
 1 | use std::process;
 2 | 
 3 | use colored::Colorize;
 4 | 
 5 | const VERSION: &str = env!("CARGO_PKG_VERSION");
 6 | 
 7 | #[derive(Debug)]
 8 | pub enum ErrorType {
 9 |     Parse,
10 |     Preprocessor,
11 |     Runtime,
12 |     Scanner
13 | }
14 | 
15 | pub fn info(message: &str) {
16 |     println!("{}", message);
17 | }
18 | 
19 | // from 1-10
20 | pub fn render_progress(progress: usize) {
21 |     print!("\r");
22 | 
23 |     let mut out = String::new();
24 | 
25 |     out.push_str(" ");
26 | 
27 |     if progress < 10 {
28 |         out.push_str(" ");
29 |     }
30 | 
31 |     out.push_str(&format!("{}", format!("{}% complete: ", progress * 10).yellow().bold()));
32 | 
33 |     out.push_str("[");
34 | 
35 |     for i in 1..=10 {
36 |         match (i <= progress, i == progress) {
37 |             (true, true) => out.push_str("=>"),
38 |             (true, false) => out.push_str("=="),
39 |             _ => out.push_str("  ")
40 |         }
41 |    }
42 | 
43 |     out.push_str("]");
44 | 
45 |     println!("\r{}", out);
46 | }
47 | 
48 | pub fn success_eval<S: AsRef<str>>(output: Option<S>) {
49 |     print!("{}", "Returned: ".bold());
50 | 
51 |     match output {
52 |         Some(output) => print!("{}", output.as_ref()),
53 |         None => print!("<null>")
54 |     }
55 | 
56 |     println!();
57 | }
58 | 
59 | pub fn success_image<S: AsRef<str>>(path: S) {
60 |     print!("{} ", "Success!".green().bold());
61 |     print!("Output to: ");
62 |     print!("{}", path.as_ref().underline());
63 |     println!();
64 | }
65 | 
66 | pub fn help() -> ! {
67 |     println!("{}", format!("bml v{}", VERSION).bold());
68 | 
69 |     println!();
70 | 
71 |     println!(" Usage: 
72 |   bml eval <script>
73 |       Evaluate script and print the returned result.
74 |   bml process <script> <image> <frames> [output_path]
75 |       Process and manipulate an image with a script and output the result, either at an automatically determined path or at a specified path.
76 |   bml new <script> <width> <height> <frames> <output_path>
77 |       Generate new image with a given width and height with a script and write the result to a path.");
78 |     
79 |     println!();
80 |     
81 |     println!(" Process and manipulate images, or generate new ones, using the Buffer Manipulation Language.");
82 | 
83 |     process::exit(1);
84 | }
85 | 
86 | pub fn report<S: AsRef<str>>(error: ErrorType, line: usize, message: S) -> ! {
87 |     println!(
88 |         "{}{}{}",
89 |         format!("{:?}Error", error).bright_red().bold(),
90 |         format!(" [line {}]", line).yellow(),
91 |         format!(": {}", message.as_ref())
92 |     );
93 | 
94 |     println!("{}", "Aborting...".bold());
95 | 
96 |     process::exit(1)
97 | }
98 | 


--------------------------------------------------------------------------------
/bml/src/macro.rs:
--------------------------------------------------------------------------------
 1 | use std::collections::HashMap;
 2 | 
 3 | use crate::{token::Token, token_type::TokenType};
 4 | 
 5 | pub struct Macro {
 6 |     keys: Vec<String>,
 7 |     template: Vec<Token>,
 8 | }
 9 | 
10 | impl Macro {
11 |     pub fn new(keys: Vec<String>, template: Vec<Token>) -> Macro {
12 |         Macro { keys, template }
13 |     }
14 | 
15 |     pub fn expand(&self, args: Vec<Vec<Token>>) -> Vec<Token> {
16 |         // dot(a, b)
17 |         let symbols = self
18 |             .keys
19 |             .clone()
20 |             .into_iter()
21 |             .zip(args.into_iter())
22 |             .collect::<HashMap<_, _>>();
23 | 
24 |         self.template
25 |             .clone()
26 |             .into_iter()
27 |             .flat_map(|t| match (t.token_type, symbols.get(&t.lexeme)) {
28 |                 (TokenType::Identifier, Some(expansion)) => expansion.clone(),
29 |                 _ => vec![t],
30 |             })
31 |             .collect::<Vec<Token>>()
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/bml/src/main.rs:
--------------------------------------------------------------------------------
  1 | use ast::Val;
  2 | use bml::{
  3 |     ast::{self, eval, Sampler},
  4 |     logger::{help, report, success_eval, success_image, ErrorType, render_progress},
  5 | };
  6 | use image::{io::Reader as ImageReader, DynamicImage};
  7 | use rayon::prelude::*;
  8 | use std::{path::Path, process, sync::{Mutex, Arc}};
  9 | 
 10 | macro_rules! gen_runtime_idents {
 11 |     ($($x:ident $(,)? )*) => {
 12 |         struct RuntimeIdents { $($x: lasso::Spur,)* }
 13 |             impl RuntimeIdents {
 14 |                 fn new(rodeo: &mut lasso::Rodeo<lasso::Spur>) -> Self {
 15 |                     Self { $($x: rodeo.get_or_intern(stringify!($x)), )* }
 16 |                 }
 17 |             }
 18 |         }
 19 | }
 20 | 
 21 | gen_runtime_idents!(resolution, coord, frag, frame, frame_count);
 22 | 
 23 | fn main() -> Result<(), Box<dyn std::error::Error>> {
 24 |     let mut args = std::env::args().skip(1);
 25 | 
 26 |     let (script, image, output_path, width, height, frame_count) = match args.next().as_deref() {
 27 |         None => {
 28 |             help();
 29 |         }
 30 |         Some("eval") => {
 31 |             let script = if let Some(script) = args.next() {
 32 |                 script
 33 |             } else {
 34 |                 help();
 35 |             };
 36 | 
 37 |             let (rodeo, ast) = bml::string_to_ast(std::fs::read_to_string(script)?);
 38 |             let env = ast::Env::default();
 39 |             let output = eval(&ast, env, &rodeo).env.ret.take();
 40 | 
 41 |             success_eval(output.map(|v| format!("{:?}", v)));
 42 | 
 43 |             process::exit(0)
 44 |         }
 45 |         Some("process") => match (args.next(), args.next(), args.next(), args.next()) {
 46 |             (Some(script), Some(image), Some(frame_count), output) => {
 47 |                 match frame_count.parse::<usize>() {
 48 |                     Ok(frame_count) => (script, Some(image), output, None, None, frame_count),
 49 |                     _ => help(),
 50 |                 }
 51 |             }
 52 |             _ => help(),
 53 |         },
 54 |         Some("new") => match (
 55 |             args.next(),
 56 |             args.next(),
 57 |             args.next(),
 58 |             args.next(),
 59 |             args.next(),
 60 |         ) {
 61 |             (Some(script), Some(width), Some(height), Some(frame_count), Some(output)) => match (
 62 |                 frame_count.parse::<usize>(),
 63 |                 width.parse::<usize>(),
 64 |                 height.parse::<usize>(),
 65 |             ) {
 66 |                 (Ok(frames), Ok(width), Ok(height)) => (
 67 |                     script,
 68 |                     None,
 69 |                     Some(output),
 70 |                     Some(width),
 71 |                     Some(height),
 72 |                     frames,
 73 |                 ),
 74 |                 _ => help(),
 75 |             },
 76 |             _ => help(),
 77 |         },
 78 |         _ => help(),
 79 |     };
 80 | 
 81 |     // should be no additional arguments
 82 |     if args.next().is_some() {
 83 |         help();
 84 |     }
 85 | 
 86 |     let (mut rodeo, ast) = bml::string_to_ast(std::fs::read_to_string(&script)?);
 87 | 
 88 |     let buffer = match &image {
 89 |         Some(path) => ImageReader::open(path)?.decode()?.to_rgba8(),
 90 |         None => DynamicImage::new_rgba8(width.unwrap() as u32, height.unwrap() as u32).to_rgba8(),
 91 |     };
 92 | 
 93 |     let rti = RuntimeIdents::new(&mut rodeo);
 94 |     let mut env = ast::Env::with_sampler(Sampler::from(&buffer));
 95 | 
 96 |     let (width, height) = buffer.dimensions();
 97 | 
 98 |     env.set(rti.resolution, Val::Vec2(width as _, height as _));
 99 |     env.set(rti.frame_count, Val::Float(frame_count as _));
100 | 
101 |     let mut frames = Vec::with_capacity(frame_count);
102 | 
103 |     let thread_count = match std::env::var("BML_THREADS") {
104 |         Ok(threads) => threads
105 |             .parse::<usize>()
106 |             .expect("Environment variable 'BML_THREADS' was not set to a positive integer"),
107 |         Err(_) => 2,
108 |     };
109 | 
110 |     let mut out_path = match &output_path {
111 |         Some(output) => output.to_owned(),
112 |         None => {
113 |             let mut path = String::new();
114 | 
115 |             // examples/closing_circle.buf
116 |             // examples/img/rocket.png
117 | 
118 |             // -> examples/img/closing_circle_rocket.png
119 | 
120 |             let image = image.as_ref().unwrap();
121 | 
122 |             let image_prefix = &image[0..image.rfind('/').map(|x| x + 1).unwrap_or(image.len())];
123 | 
124 |             path.push_str(image_prefix);
125 | 
126 |             let script_name = Path::new(&script)
127 |                 .file_stem()
128 |                 .and_then(|x| x.to_str())
129 |                 .expect("Could not extract stem from script path");
130 | 
131 |             path.push_str(script_name);
132 | 
133 |             let image_name = Path::new(image)
134 |                 .file_name()
135 |                 .and_then(|x| x.to_str())
136 |                 .expect("Could not extract file name from image path");
137 |             let image_name = &image_name[0..image_name.rfind('.').unwrap_or(image_name.len())];
138 | 
139 |             path.push('_');
140 |             path.push_str(image_name);
141 | 
142 |             path
143 |         }
144 |     };
145 | 
146 |     let progress = Arc::new(Mutex::new(0));
147 | 
148 |     (0..frame_count).for_each(|frame| {
149 |         env.set(rti.frame, Val::Float(frame as _));
150 | 
151 |         let size = (width * height) as usize;
152 | 
153 |         let net_pixels = size * frame_count;
154 | 
155 |         let mut frame = (0..thread_count)
156 |             .into_par_iter()
157 |             .map(|i| {
158 |                 let result = (
159 |                     i,
160 |                     (size * i / thread_count..size * (i + 1) / thread_count)
161 |                         .flat_map(|index| {
162 |                             let x = (index as u32) % width;
163 |                             let y = (index as u32) / width;
164 | 
165 |                             // println!("{} {} {}", index, x, y);
166 |                             let [r, g, b, a] = buffer.get_pixel(x, y).0;
167 | 
168 |                             let mut env = env.clone();
169 | 
170 |                             env.set(rti.coord, Val::Vec2(x as _, y as _));
171 |                             env.set(
172 |                                 rti.frag,
173 |                                 Val::Vec4(
174 |                                     r as f32 / 255.0,
175 |                                     g as f32 / 255.0,
176 |                                     b as f32 / 255.0,
177 |                                     a as f32 / 255.0,
178 |                                 ),
179 |                             );
180 | 
181 |                             let mut ret = ast::eval(&ast, env, &rodeo);
182 | 
183 |                             let mut progress = progress.lock().unwrap();
184 | 
185 |                             *progress += 1;
186 | 
187 |                             if *progress % (net_pixels / 10) == 0 {
188 |                                 let percent = ((*progress as f32) / (net_pixels as f32) * 10.0) as usize;
189 |                                 render_progress(percent);
190 |                             }
191 | 
192 |                             match ret.env.ret.take() {
193 |                                 Some(Val::Vec4(r, g, b, a)) => [
194 |                                     (255.0 * r) as u8,
195 |                                     (255.0 * g) as u8,
196 |                                     (255.0 * b) as u8,
197 |                                     (255.0 * a) as u8,
198 |                                 ],
199 |                                 None => report(
200 |                                     ErrorType::Runtime,
201 |                                     ast.line,
202 |                                     "Expected program to return vec4, got nothing",
203 |                                 ),
204 |                                 Some(val) => report(
205 |                                     ErrorType::Runtime,
206 |                                     ast.line,
207 |                                     format!("Returned color must be vec4, got {:?}", val),
208 |                                 ),
209 |                             }
210 |                         })
211 |                         .collect::<Vec<u8>>(),
212 |                 );
213 | 
214 |                 result
215 |             })
216 |             .collect::<Vec<(usize, Vec<u8>)>>();
217 | 
218 |         frame.sort_by(|(idx1, _), (idx2, _)| idx1.cmp(idx2));
219 | 
220 |         let frame = frame
221 |             .into_iter()
222 |             .flat_map(|(_, vec)| vec)
223 |             .collect::<Vec<u8>>();
224 | 
225 |         frames.push(frame);
226 |     });
227 | 
228 |     let bytes_to_dynimg = move |bytes: Vec<u8>| -> image::RgbaImage {
229 |         image::ImageBuffer::from_raw(width, height, bytes).unwrap()
230 |     };
231 | 
232 |     match frame_count {
233 |         0 => panic!("Expected positive number of frames for image/gif generations, got 0"),
234 |         1 => {
235 |             if output_path.is_none() {
236 |                 out_path.push_str(".png");
237 |             }
238 | 
239 |             bytes_to_dynimg(frames.pop().unwrap()).save(&out_path)?
240 |         }
241 |         _ => {
242 |             if output_path.is_none() {
243 |                 out_path.push_str(".gif");
244 |             }
245 | 
246 |             use image::codecs::gif::*;
247 |             use std::fs::File;
248 |             let mut encoder = GifEncoder::new(File::create(&out_path)?);
249 |             let delay = image::Delay::from_numer_denom_ms(1000, 10);
250 |             encoder.set_repeat(Repeat::Infinite)?;
251 |             encoder.encode_frames(
252 |                 frames
253 |                     .into_iter()
254 |                     .map(bytes_to_dynimg)
255 |                     .map(|img| image::Frame::from_parts(img, 0, 0, delay)),
256 |             )?;
257 |         }
258 |     }
259 | 
260 |     success_image(out_path.as_str());
261 | 
262 |     Ok(())
263 | }
264 | 


--------------------------------------------------------------------------------
/bml/src/parser.rs:
--------------------------------------------------------------------------------
  1 | use std::collections::HashMap;
  2 | 
  3 | use lasso::{Rodeo, Spur};
  4 | 
  5 | use crate::ast::{Ast, BuiltIn, Field, Op, SrcAst, Swizzle, Val};
  6 | use crate::logger::{report, ErrorType};
  7 | use crate::token::Token;
  8 | use crate::token_type::TokenType;
  9 | 
 10 | pub struct Parser<'a> {
 11 |     tokens: &'a Vec<Token>,
 12 |     current: usize,
 13 |     pub rodeo: Rodeo<Spur>,
 14 |     builtins: HashMap<String, BuiltIn>,
 15 |     lines: Vec<SrcAst>,
 16 | }
 17 | 
 18 | macro_rules! builtins {
 19 |     ($( ($key:expr, $value:expr) ),*) => {{
 20 |         let mut map = HashMap::new();
 21 |         $( map.insert(String::from($key), $value); )*
 22 |         map
 23 |     }};
 24 | }
 25 | 
 26 | impl<'a> Parser<'a> {
 27 |     pub fn from(tokens: &Vec<Token>) -> Parser {
 28 |         let builtins = builtins!(
 29 |             ("sample", BuiltIn::Sample),
 30 |             ("dist", BuiltIn::Dist),
 31 |             ("radians", BuiltIn::Radians),
 32 |             ("degrees", BuiltIn::Degrees),
 33 |             ("sin", BuiltIn::Sin),
 34 |             ("cos", BuiltIn::Cos),
 35 |             ("tan", BuiltIn::Tan),
 36 |             ("asin", BuiltIn::Asin),
 37 |             ("acos", BuiltIn::Acos),
 38 |             ("atan", BuiltIn::Atan),
 39 |             ("pow", BuiltIn::Pow),
 40 |             ("exp", BuiltIn::Exp),
 41 |             ("log", BuiltIn::Log),
 42 |             ("sqrt", BuiltIn::Sqrt),
 43 |             ("invsqrt", BuiltIn::InverseSqrt),
 44 |             ("abs", BuiltIn::Abs),
 45 |             ("sign", BuiltIn::Sign),
 46 |             ("floor", BuiltIn::Floor),
 47 |             ("ceil", BuiltIn::Ceil),
 48 |             ("fract", BuiltIn::Fract),
 49 |             ("mod", BuiltIn::Mod),
 50 |             ("min", BuiltIn::Min),
 51 |             ("max", BuiltIn::Max),
 52 |             ("clamp", BuiltIn::Clamp),
 53 |             ("mix", BuiltIn::Mix),
 54 |             ("step", BuiltIn::Step),
 55 |             ("length", BuiltIn::Length),
 56 |             ("dot", BuiltIn::Dot),
 57 |             ("cross", BuiltIn::Cross),
 58 |             ("norm", BuiltIn::Norm),
 59 |             ("mat2", BuiltIn::Mat2),
 60 |             ("mat3", BuiltIn::Mat3),
 61 |             ("mat4", BuiltIn::Mat4),
 62 |             ("rotate_x", BuiltIn::RotateX),
 63 |             ("rotate_y", BuiltIn::RotateY),
 64 |             ("rotate_z", BuiltIn::RotateZ),
 65 |             ("rotate", BuiltIn::Rotate),
 66 |             ("scale", BuiltIn::Scale),
 67 |             ("translate", BuiltIn::Translate),
 68 |             ("ortho", BuiltIn::Ortho),
 69 |             ("lookat", BuiltIn::LookAt),
 70 |             ("perspective", BuiltIn::Perspective)
 71 |         );
 72 | 
 73 |         Parser {
 74 |             tokens,
 75 |             current: 0,
 76 |             rodeo: Rodeo::new(),
 77 |             builtins,
 78 |             lines: Vec::new(),
 79 |         }
 80 |     }
 81 | 
 82 |     pub fn parse(mut self) -> (Rodeo, SrcAst) {
 83 |         while !self.at_end() {
 84 |             let statement = self.statement();
 85 | 
 86 |             self.lines.push(statement);
 87 |         }
 88 | 
 89 |         let prev = if self.tokens.len() > 0 {
 90 |             0
 91 |         } else {
 92 |             self.previous().line
 93 |         };
 94 |         let Self { rodeo, lines, .. } = self;
 95 |         (rodeo, SrcAst::new(Ast::Block(lines), prev))
 96 |     }
 97 | 
 98 |     fn statement(&mut self) -> SrcAst {
 99 |         if self.check(TokenType::Identifier) 
100 |             && self.check_next(TokenType::Equals) 
101 |         {
102 |             self.advance();
103 |             return self.assign();
104 |         }
105 | 
106 |         if self.match_token(TokenType::Return) {
107 |             return self.r#return();
108 |         }
109 | 
110 |         if self.match_token(TokenType::Repeat) {
111 |             return self.repeat();
112 |         }
113 | 
114 |         if self.match_token(TokenType::While) {
115 |             return self.r#while();
116 |         }
117 | 
118 |         self.r#if()
119 |     }
120 | 
121 |     fn r#while(&mut self) -> SrcAst {
122 |         let cond = self.expression();
123 | 
124 |         self.consume(TokenType::Comma, "Expected ',' in while statement");
125 | 
126 |         if !self.match_token(TokenType::Number) {
127 |             report(
128 |                 ErrorType::Parse,
129 |                 self.peek().line,
130 |                 format!(
131 |                     "Expected positive number literal in while statement, got '{}'",
132 |                     self.peek().lexeme
133 |                 )
134 |                 .as_str(),
135 |             );
136 |         }
137 | 
138 |         let times = match self.previous().lexeme.parse::<f32>() {
139 |             Ok(times) => times,
140 |             Err(_) => report(
141 |                 ErrorType::Parse,
142 |                 self.previous().line,
143 |                 format!(
144 |                     "Expected number literal in while statement, got '{}'",
145 |                     self.previous().lexeme
146 |                 )
147 |                 .as_str(),
148 |             ),
149 |         };
150 | 
151 |         if !self.match_token(TokenType::LeftBracket) {
152 |             report(
153 |                 ErrorType::Parse,
154 |                 self.previous().line,
155 |                 format!(
156 |                     "Expected '{{' in while block, got '{}'",
157 |                     self.previous().lexeme
158 |                 )
159 |                 .as_str(),
160 |             );
161 |         }
162 | 
163 |         let block = self.block();
164 | 
165 |         SrcAst::new(Ast::While(Box::new(cond), times, Box::new(block)), self.previous().line)
166 |     }
167 | 
168 |     fn repeat(&mut self) -> SrcAst {
169 |         if !self.match_token(TokenType::Number) {
170 |             report(
171 |                 ErrorType::Parse,
172 |                 self.peek().line,
173 |                 format!(
174 |                     "Expected positive number literal in repeat statement, got '{}'",
175 |                     self.peek().lexeme
176 |                 )
177 |                 .as_str(),
178 |             );
179 |         }
180 | 
181 |         let times = match self.previous().lexeme.parse::<f32>() {
182 |             Ok(times) => times,
183 |             Err(_) => report(
184 |                 ErrorType::Parse,
185 |                 self.previous().line,
186 |                 format!(
187 |                     "Expected number literal in repeat statement, got '{}'",
188 |                     self.previous().lexeme
189 |                 )
190 |                 .as_str(),
191 |             ),
192 |         };
193 | 
194 |         if !self.match_token(TokenType::LeftBracket) {
195 |             report(
196 |                 ErrorType::Parse,
197 |                 self.previous().line,
198 |                 format!(
199 |                     "Expected '{{' in repeat block, got '{}'",
200 |                     self.previous().lexeme
201 |                 )
202 |                 .as_str(),
203 |             );
204 |         }
205 | 
206 |         let block = self.block();
207 | 
208 |         SrcAst::new(Ast::Repeat(times, Box::new(block)), self.previous().line)
209 |     }
210 | 
211 |     fn r#if(&mut self) -> SrcAst {
212 |         let mut expression = self.expression();
213 | 
214 |         if self.match_token(TokenType::If) {
215 |             let condition = self.expression();
216 | 
217 |             self.consume(TokenType::Else, "Expected 'else' in if expression");
218 | 
219 |             let false_ret = self.expression();
220 | 
221 |             expression = SrcAst::new(
222 |                 Ast::If {
223 |                     cond: Box::new(condition),
224 |                     true_ret: Box::new(expression),
225 |                     false_ret: Box::new(false_ret),
226 |                 },
227 |                 self.previous().line,
228 |             );
229 |         }
230 | 
231 |         SrcAst::new(expression.ast, self.previous().line)
232 |     }
233 | 
234 |     fn r#return(&mut self) -> SrcAst {
235 |         let expression = self.r#if();
236 | 
237 |         SrcAst::new(Ast::Return(Box::new(expression)), self.previous().line)
238 |     }
239 | 
240 |     fn assign(&mut self) -> SrcAst {
241 |         let name = self.previous().lexeme;
242 | 
243 |         self.consume(TokenType::Equals, "Expected '=' after variable declaration");
244 | 
245 |         let initializer = self.r#if();
246 | 
247 |         SrcAst::new(
248 |             Ast::Assign(self.identifier(name), Box::new(initializer)),
249 |             self.previous().line,
250 |         )
251 |     }
252 | 
253 |     fn expression(&mut self) -> SrcAst {
254 |         self.equality()
255 |     }
256 | 
257 |     fn equality(&mut self) -> SrcAst {
258 |         let mut equality = self.comparison();
259 | 
260 |         while self.match_token(TokenType::EqualsEquals) 
261 |             || self.match_token(TokenType::NotEquals)
262 |         {
263 |             let operator = match self.previous().token_type {
264 |                 TokenType::EqualsEquals => Op::Equal,
265 |                 TokenType::NotEquals => Op::NotEqual,
266 |                 _ => report(
267 |                     ErrorType::Parse,
268 |                     self.previous().line,
269 |                     format!("Unexpected binary operator \'{}\'", self.previous().lexeme),
270 |                 ),
271 |             };
272 | 
273 |             let right = self.comparison();
274 | 
275 |             equality = SrcAst::new(
276 |                 Ast::BinOp(Box::new(equality), operator, Box::new(right)),
277 |                 self.previous().line,
278 |             );
279 |         }
280 | 
281 |         equality
282 |     }
283 | 
284 |     fn access(&mut self) -> SrcAst {
285 |         let mut access = self.index();
286 | 
287 |         if self.match_token(TokenType::Dot) {
288 |             let mut accessors = Vec::new();
289 | 
290 |             loop {
291 |                 let token = self.advance();
292 | 
293 |                 match token.token_type {
294 |                     TokenType::X => accessors.push(Field::X),
295 |                     TokenType::Y => accessors.push(Field::Y),
296 |                     TokenType::Z => accessors.push(Field::Z),
297 |                     TokenType::W => accessors.push(Field::W),
298 |                     _ => {
299 |                         self.current -= 1;
300 |                         break;
301 |                     } // _ => panic!("[line {}] Error: Expected 'x', 'y', 'z', 'w', 'r', 'g', 'b', or 'a', got {}", token.line, token.lexeme)
302 |                 }
303 |             }
304 | 
305 |             if accessors.len() < 1 {
306 |                 report(
307 |                     ErrorType::Parse,
308 |                     self.previous().line,
309 |                     "Expected at least one component when swizzling",
310 |                 );
311 |             }
312 | 
313 |             access = SrcAst::new(
314 |                 Ast::VecAccess(
315 |                     Box::new(access),
316 |                     Swizzle(
317 |                         *accessors.get(0).unwrap(),
318 |                         accessors.get(1).copied(),
319 |                         accessors.get(2).copied(),
320 |                         accessors.get(3).copied(),
321 |                     ),
322 |                 ),
323 |                 self.previous().line,
324 |             );
325 |         }
326 | 
327 |         access
328 |     }
329 | 
330 |     fn index(&mut self) -> SrcAst {
331 |         let mut value = self.primary();
332 | 
333 |         if self.match_token(TokenType::LeftSquare) {
334 |             let index = self.expression();
335 | 
336 |             self.consume(TokenType::RightSquare, "Expected ']' when indexing matrix");
337 | 
338 |             value = SrcAst::new(
339 |                 Ast::MatAccess(Box::new(value), Box::new(index)),
340 |                 self.previous().line,
341 |             );
342 |         }
343 | 
344 |         value
345 |     }
346 | 
347 |     fn comparison(&mut self) -> SrcAst {
348 |         let mut term = self.term();
349 | 
350 |         loop {
351 |             let token = self.peek();
352 | 
353 |             let op = match token.token_type {
354 |                 TokenType::LessThan => Some(Op::Less),
355 |                 TokenType::GreaterThan => Some(Op::More),
356 |                 TokenType::LessThanEquals => Some(Op::LessEq),
357 |                 TokenType::GreaterThanEquals => Some(Op::MoreEq),
358 |                 _ => None,
359 |             };
360 | 
361 |             if op.is_none() {
362 |                 break;
363 |             }
364 | 
365 |             // advance cursor if comparison operand
366 |             self.current += 1;
367 | 
368 |             let op = op.unwrap();
369 | 
370 |             let right = self.term();
371 | 
372 |             term = SrcAst::new(
373 |                 Ast::BinOp(Box::new(term), op, Box::new(right)),
374 |                 self.previous().line,
375 |             );
376 |         }
377 | 
378 |         term
379 |     }
380 | 
381 |     fn term(&mut self) -> SrcAst {
382 |         let mut factor = self.factor();
383 | 
384 |         loop {
385 |             let token = self.peek();
386 | 
387 |             let op = match token.token_type {
388 |                 TokenType::Plus => Some(Op::Add),
389 |                 TokenType::Minus => Some(Op::Sub),
390 |                 _ => None,
391 |             };
392 | 
393 |             if op.is_none() {
394 |                 break;
395 |             }
396 | 
397 |             // advance cursor
398 |             self.current += 1;
399 | 
400 |             let op = op.unwrap();
401 | 
402 |             let right = self.factor();
403 | 
404 |             factor = SrcAst::new(
405 |                 Ast::BinOp(Box::new(factor), op, Box::new(right)),
406 |                 self.previous().line,
407 |             );
408 |         }
409 | 
410 |         factor
411 |     }
412 | 
413 |     fn factor(&mut self) -> SrcAst {
414 |         let mut primary = self.access();
415 | 
416 |         loop {
417 |             let token = self.peek();
418 | 
419 |             let op = match token.token_type {
420 |                 TokenType::Star => Some(Op::Mul),
421 |                 TokenType::Slash => Some(Op::Div),
422 |                 _ => None,
423 |             };
424 | 
425 |             if op.is_none() {
426 |                 break;
427 |             }
428 | 
429 |             // advance cursor
430 |             self.current += 1;
431 | 
432 |             let op = op.unwrap();
433 | 
434 |             let right = self.access();
435 | 
436 |             primary = SrcAst::new(
437 |                 Ast::BinOp(Box::new(primary), op, Box::new(right)),
438 |                 self.previous().line,
439 |             );
440 |         }
441 | 
442 |         primary
443 |     }
444 | 
445 |     fn primary(&mut self) -> SrcAst {
446 |         if self.peek().token_type == TokenType::Identifier
447 |             && self.peek_next().token_type == TokenType::LeftParen
448 |         {
449 |             self.current += 1;
450 |             return self.call();
451 |         }
452 | 
453 |         if self.match_token(TokenType::LeftParen) {
454 |             let expression = self.r#if();
455 | 
456 |             self.consume(TokenType::RightParen, "Unclosed ')' in expression");
457 | 
458 |             // handle parenthesis
459 |             return SrcAst::new(
460 |                 Ast::Block(vec![SrcAst::new(
461 |                     Ast::Give(Box::new(expression)),
462 |                     self.previous().line,
463 |                 )]),
464 |                 self.previous().line,
465 |             );
466 |         }
467 | 
468 |         if self.match_token(TokenType::LeftBracket) {
469 |             return self.block();
470 |         }
471 | 
472 |         if self.match_token(TokenType::Identifier) {
473 |             return self.identity();
474 |         }
475 | 
476 |         self.literal()
477 |     }
478 | 
479 |     fn literal(&mut self) -> SrcAst {
480 |         // number literal
481 |         if self.check(TokenType::Minus) && self.check_next(TokenType::Number) {
482 |             // consume - and number
483 |             self.advance();
484 |             self.advance();
485 | 
486 |             return self.number(false);
487 |         }
488 | 
489 |         if self.match_token(TokenType::Number) {
490 |             return self.number(true);
491 |         }
492 | 
493 |         if self.match_token(TokenType::LeftSquare) {
494 |             return self.vector();
495 |         }
496 | 
497 |         if self.at_end() {
498 |             report(
499 |                 ErrorType::Parse,
500 |                 self.peek().line,
501 |                 "Unexpected EoF -- did you forget a ']' or '}'?"
502 |             )
503 |         }
504 | 
505 |         report(
506 |             ErrorType::Parse,
507 |             self.peek().line,
508 |             format!("Unexpected '{}' in expression", self.peek().lexeme),
509 |         )
510 |     }
511 | 
512 |     fn vector(&mut self) -> SrcAst {
513 |         let first = self.r#if();
514 | 
515 |         if self.match_token(TokenType::Semi) {
516 |             self.consume(
517 |                 TokenType::Number,
518 |                 "Expected scalar literal as length in vector",
519 |             );
520 | 
521 |             let length = self.number(true);
522 | 
523 |             self.consume(
524 |                 TokenType::RightSquare,
525 |                 "vector literals must end with ']' and be up to 4 components",
526 |             );
527 | 
528 |             return SrcAst::new(
529 |                 Ast::VecRepeated(Box::new(first), Box::new(length)),
530 |                 self.previous().line,
531 |             );
532 |         }
533 | 
534 |         self.consume(TokenType::Comma, "Expected ',' in vector arguments");
535 | 
536 |         let second = self.r#if();
537 | 
538 |         let third = if self.match_token(TokenType::Comma) {
539 |             let expression = self.r#if();
540 |             Some(Box::new(expression))
541 |         } else {
542 |             None
543 |         };
544 | 
545 |         let fourth = if self.match_token(TokenType::Comma) {
546 |             Some(Box::new(self.r#if()))
547 |         } else {
548 |             None
549 |         };
550 | 
551 |         self.consume(
552 |             TokenType::RightSquare,
553 |             "vector literals must end with ']' and be up to 4 components",
554 |         );
555 | 
556 |         SrcAst::new(
557 |             Ast::VecLiteral(Box::new(first), Box::new(second), third, fourth),
558 |             self.previous().line,
559 |         )
560 |     }
561 | 
562 |     fn number(&mut self, positive: bool) -> SrcAst {
563 |         let sign = if positive { 1.0 } else { -1.0 };
564 | 
565 |         SrcAst::new(
566 |             Ast::V(Val::Float(
567 |                 sign * self.previous().lexeme.parse::<f32>().unwrap(),
568 |             )),
569 |             self.previous().line,
570 |         )
571 |     }
572 | 
573 |     fn identity(&mut self) -> SrcAst {
574 |         SrcAst::new(
575 |             Ast::Ident(self.rodeo.get_or_intern(self.previous().lexeme)),
576 |             self.previous().line,
577 |         )
578 |     }
579 | 
580 |     fn call(&mut self) -> SrcAst {
581 |         let token = self.previous();
582 |         let name = &token.lexeme;
583 | 
584 |         let builtin = if let Some(&builtin) = self.builtins.get(name) {
585 |             builtin
586 |         } else {
587 |             report(
588 |                 ErrorType::Parse,
589 |                 token.line,
590 |                 format!("Built-in function '{}' does not exist", name),
591 |             )
592 |         };
593 | 
594 |         self.consume(
595 |             TokenType::LeftParen,
596 |             "Expected \'(\' in built-in function call",
597 |         );
598 | 
599 |         let mut arguments = Vec::new();
600 | 
601 |         while !self.check(TokenType::RightParen) {
602 |             let expression = self.r#if();
603 | 
604 |             self.match_token(TokenType::Comma);
605 | 
606 |             arguments.push(expression);
607 |         }
608 | 
609 |         self.consume(
610 |             TokenType::RightParen,
611 |             "Expected \')\' in built-in function call",
612 |         );
613 | 
614 |         SrcAst::new(Ast::Call(builtin, arguments), self.previous().line)
615 |     }
616 | 
617 |     fn block(&mut self) -> SrcAst {
618 |         let mut statements = Vec::new();
619 | 
620 |         while !self.match_token(TokenType::RightBracket) {
621 |             if self.match_token(TokenType::Give) {
622 |                 statements.push(self.give());
623 |             } else {
624 |                 statements.push(self.statement());
625 |             }
626 |         }
627 | 
628 |         SrcAst::new(Ast::Block(statements), self.previous().line)
629 |     }
630 | 
631 |     fn give(&mut self) -> SrcAst {
632 |         let expression = self.r#if();
633 | 
634 |         SrcAst::new(Ast::Give(Box::new(expression)), self.previous().line)
635 |     }
636 | 
637 |     fn match_token(&mut self, token_type: TokenType) -> bool {
638 |         if self.check(token_type) {
639 |             self.advance();
640 |             return true;
641 |         }
642 | 
643 |         false
644 |     }
645 | 
646 |     fn identifier(&mut self, name: String) -> Spur {
647 |         self.rodeo.get_or_intern(name)
648 |     }
649 | 
650 |     fn consume(&mut self, token_type: TokenType, error: &str) -> Token {
651 |         if self.peek().token_type == token_type {
652 |             return self.advance();
653 |         }
654 | 
655 |         report(ErrorType::Parse, self.peek().line, error);
656 |     }
657 | 
658 |     fn advance(&mut self) -> Token {
659 |         if !self.at_end() {
660 |             self.current += 1;
661 |         }
662 | 
663 |         self.previous()
664 |     }
665 | 
666 |     fn previous(&self) -> Token {
667 |         self.tokens[self.current - 1].clone()
668 |     }
669 | 
670 |     fn check_next(&self, token_type: TokenType) -> bool {
671 |         self.current + 1 < self.tokens.len() && self.peek_next().token_type == token_type
672 |     }
673 | 
674 |     fn check(&self, token_type: TokenType) -> bool {
675 |         !self.at_end() && self.peek().token_type == token_type
676 |     }
677 | 
678 |     fn at_end(&self) -> bool {
679 |         self.peek().token_type == TokenType::Eof
680 |     }
681 | 
682 |     fn peek_next(&self) -> &Token {
683 |         self.tokens.get(self.current + 1).expect("Unexpected EOF")
684 |     }
685 | 
686 |     fn peek(&self) -> &Token {
687 |         self.tokens.get(self.current).expect("Unexpected EOF")
688 |     }
689 | }
690 | 


--------------------------------------------------------------------------------
/bml/src/preprocessor.rs:
--------------------------------------------------------------------------------
  1 | use std::collections::HashMap;
  2 | 
  3 | use crate::{
  4 |     logger::{report, ErrorType},
  5 |     r#macro::Macro,
  6 |     token::Token,
  7 |     token_type::TokenType,
  8 | };
  9 | 
 10 | #[derive(Default)]
 11 | pub struct Arg {
 12 |     parens: usize,
 13 |     square_brackets: usize,
 14 |     brackets: usize,
 15 |     pub lexeme: Vec<Token>,
 16 | }
 17 | 
 18 | impl Arg {
 19 |     pub fn is_closed(&self) -> bool {
 20 |         self.parens == 0 && self.brackets == 0 && self.square_brackets == 0
 21 |     }
 22 | 
 23 |     pub fn new_token(&mut self, token: Token) -> Result<(), &str> {
 24 |         match token.token_type {
 25 |             TokenType::LeftParen => self.parens += 1,
 26 |             TokenType::RightParen => {
 27 |                 if self.parens == 0 {
 28 |                     return Err("Unexpected ')' in macro arguments");
 29 |                 } else {
 30 |                     self.parens -= 1
 31 |                 }
 32 |             },
 33 |             TokenType::LeftBracket => self.brackets += 1,
 34 |             TokenType::RightBracket => {
 35 |                 if self.brackets == 0 {
 36 |                     return Err("Unexpected '}' in macro arguments");
 37 |                 } else {
 38 |                     self.brackets -= 1
 39 |                 }
 40 |             },
 41 |             TokenType::LeftSquare => self.square_brackets += 1,
 42 |             TokenType::RightSquare => {
 43 |                 if self.square_brackets == 0 {
 44 |                     return Err("Unexpected ']' in macro arguments");
 45 |                 } else {
 46 |                     self.square_brackets -= 1
 47 |                 }
 48 |             },
 49 |             _ => {}
 50 |         }
 51 | 
 52 |         self.lexeme.push(token);
 53 | 
 54 |         Ok(())
 55 |     }
 56 | }
 57 | 
 58 | pub struct PreProcessor {
 59 |     tokens: Vec<Token>,
 60 |     result: Vec<Token>,
 61 |     current: usize,
 62 |     macros: HashMap<String, Macro>,
 63 | }
 64 | 
 65 | impl PreProcessor {
 66 |     pub fn from(tokens: Vec<Token>) -> PreProcessor {
 67 |         PreProcessor {
 68 |             tokens,
 69 |             result: vec![],
 70 |             current: 0,
 71 |             macros: HashMap::new(),
 72 |         }
 73 |     }
 74 | 
 75 |     pub fn process(mut self) -> Vec<Token> {
 76 |         while !self.at_end() {
 77 |             let token = self.advance();
 78 | 
 79 |             match token.token_type {
 80 |                 // macro definition
 81 |                 TokenType::Macro => {
 82 |                     let name = self.consume(TokenType::Identifier);
 83 | 
 84 |                     if name.is_none() {
 85 |                         report(
 86 |                             ErrorType::Preprocessor,
 87 |                             token.line,
 88 |                             "Expected macro definition",
 89 |                         );
 90 |                     }
 91 | 
 92 |                     let name = name.unwrap();
 93 | 
 94 |                     if self.consume(TokenType::LeftParen).is_none() {
 95 |                         report(
 96 |                             ErrorType::Preprocessor,
 97 |                             token.line,
 98 |                             "Expected opening parenthesis",
 99 |                         );
100 |                     }
101 | 
102 |                     // read parameters
103 |                     let mut parameters = Vec::new();
104 | 
105 |                     while self.consume(TokenType::RightParen).is_none() {
106 |                         let parameter = self.consume(TokenType::Identifier);
107 | 
108 |                         if parameter.is_none() {
109 |                             report(
110 |                                 ErrorType::Preprocessor,
111 |                                 token.line,
112 |                                 "Expected parameter in macro definition",
113 |                             );
114 |                         }
115 | 
116 |                         parameters.push(parameter.unwrap().lexeme);
117 | 
118 |                         self.consume(TokenType::Comma);
119 |                     }
120 | 
121 |                     let mut template = Vec::new();
122 | 
123 |                     // read to rest of line for macro template expansion
124 | 
125 |                     let mut brackets = 0;
126 | 
127 |                     while !self.at_end() && (self.peek().line == token.line || brackets > 0) {
128 |                         let template_token = self.advance();
129 | 
130 |                         match template_token.token_type {
131 |                             TokenType::LeftBracket => brackets += 1,
132 |                             TokenType::RightBracket => {
133 |                                 if brackets == 0 {
134 |                                     report(
135 |                                         ErrorType::Preprocessor,
136 |                                         self.peek().line,
137 |                                         "Unexpected '}'",
138 |                                     )
139 |                                 }
140 | 
141 |                                 brackets -= 1
142 |                             }
143 |                             _ => {}
144 |                         };
145 | 
146 |                         if template_token.token_type == TokenType::Identifier
147 |                             && self.peek().token_type == TokenType::LeftParen
148 |                             && self.macros.contains_key(&template_token.lexeme)
149 |                         {
150 |                             let start = self.current - 1;
151 |                             self.consume(TokenType::LeftParen);
152 |                             let mut parens = 1;
153 | 
154 |                             while !self.at_end() && parens > 0 {
155 |                                 let t = self.advance();
156 | 
157 |                                 match t.token_type {
158 |                                     TokenType::LeftParen => parens += 1,
159 |                                     TokenType::RightParen => parens -= 1,
160 |                                     TokenType::RightBracket => brackets += 1,
161 |                                     TokenType::LeftBracket => brackets -= 1,
162 |                                     _ => {}
163 |                                 };
164 |                             }
165 | 
166 |                             if parens > 0 {
167 |                                 report(
168 |                                     ErrorType::Preprocessor,
169 |                                     self.previous().line,
170 |                                     "Expected ')' in macro definition",
171 |                                 );
172 |                             }
173 | 
174 |                             let nested_call = self.tokens[start..self.current].to_owned();
175 |                             let mut expansion = self.expand_macro(token.line, &nested_call);
176 | 
177 |                             template.append(&mut expansion)
178 |                         } else {
179 |                             template.push(template_token)
180 |                         }
181 |                     }
182 | 
183 |                     if brackets > 0 {
184 |                         report(
185 |                             ErrorType::Preprocessor,
186 |                             self.peek().line,
187 |                             format!("Expected '}}' in '{}' macro definition", name.lexeme),
188 |                         );
189 |                     }
190 | 
191 |                     self.macros
192 |                         .insert(name.lexeme, Macro::new(parameters, template));
193 |                 }
194 | 
195 |                 // macro calls
196 |                 TokenType::Identifier => {
197 |                     if self.peek().token_type == TokenType::LeftParen
198 |                         && self.macros.contains_key(&token.lexeme)
199 |                     {
200 |                         let start = self.current - 1;
201 | 
202 |                         self.consume(TokenType::LeftParen);
203 | 
204 |                         let mut parens = 1;
205 | 
206 |                         while !self.at_end() && parens > 0 {
207 |                             match self.advance().token_type {
208 |                                 TokenType::LeftParen => parens += 1,
209 |                                 TokenType::RightParen => parens -= 1,
210 |                                 _ => {}
211 |                             }
212 |                         }
213 | 
214 |                         // if reached EoF w/o parens == 0
215 |                         if parens != 0 {
216 |                             report(
217 |                                 ErrorType::Preprocessor,
218 |                                 self.previous().line,
219 |                                 "Missing ')' when parsing macro call",
220 |                             );
221 |                         }
222 | 
223 |                         let nested_call = self.tokens[start..self.current].to_owned();
224 |                         let mut expansion = self.expand_macro(token.line, &nested_call);
225 | 
226 |                         self.result.append(&mut expansion);
227 |                     } else {
228 |                         self.result.push(token);
229 |                     }
230 |                 }
231 | 
232 |                 _ => {
233 |                     self.result.push(token);
234 |                 }
235 |             }
236 |         }
237 | 
238 |         self.result
239 |     }
240 | 
241 |     // dot([expr], [expr]) -> expansion
242 |     fn expand_macro(&self, line: usize, call: &Vec<Token>) -> Vec<Token> {
243 |         // assert that call starts with identifier, has left paren,
244 |         let name = match call.get(0) {
245 |             Some(token) => {
246 |                 if token.token_type != TokenType::Identifier {
247 |                     report(
248 |                         ErrorType::Preprocessor,
249 |                         token.line,
250 |                         format!(
251 |                             "Expected macro call to start with identifier, got '{:?}'",
252 |                             token.lexeme
253 |                         )
254 |                         .as_str(),
255 |                     );
256 |                 }
257 | 
258 |                 token
259 |             }
260 |             None => {
261 |                 report(
262 |                     ErrorType::Preprocessor,
263 |                     line,
264 |                     "Expected macro call to have non-zero length",
265 |                 );
266 |             }
267 |         };
268 | 
269 |         match call.get(1) {
270 |             Some(Token {
271 |                 token_type: TokenType::LeftParen,
272 |                 ..
273 |             }) => {}
274 |             _ => {
275 |                 report(
276 |                     ErrorType::Preprocessor,
277 |                     line,
278 |                     "Expected '(' in macro invocation",
279 |                 );
280 |             }
281 |         }
282 | 
283 |         let mut cursor = 2;
284 |         let mut current_arg = Arg::default();
285 |         let mut args = Vec::new();
286 | 
287 |         loop {
288 |             match call.get(cursor) {
289 |                 None => {
290 |                     report(ErrorType::Preprocessor, line, "Expected ')' in macro call");
291 |                 }
292 |                 Some(token) => {
293 |                     let mut is_arg_comma = false;
294 | 
295 |                     match token.token_type {
296 |                         TokenType::Comma => {
297 |                             if current_arg.is_closed() {
298 |                                 if current_arg.lexeme.is_empty() {
299 |                                     report(ErrorType::Preprocessor, line, "Unexpected ',' in macro arguments");
300 |                                 }
301 | 
302 |                                 args.push(current_arg.lexeme);
303 |                                 current_arg = Arg::default();
304 | 
305 |                                 is_arg_comma = true;
306 |                             }
307 |                         }
308 |                         TokenType::RightParen => {
309 |                             if current_arg.is_closed() {
310 |                                 if !current_arg.lexeme.is_empty() {
311 |                                     args.push(current_arg.lexeme);
312 |                                 }
313 | 
314 |                                 break;
315 |                             }
316 |                         }
317 |                         TokenType::Identifier => {
318 |                             if self.macros.contains_key(&token.lexeme) {
319 |                                 let start = cursor;
320 | 
321 |                                 loop {
322 |                                     match call.get(cursor) {
323 |                                         Some(Token {
324 |                                             token_type: TokenType::RightParen,
325 |                                             ..
326 |                                         }) => {
327 |                                             cursor += 1;
328 |                                             break;
329 |                                         }
330 |                                         None => {
331 |                                             report(
332 |                                                 ErrorType::Preprocessor,
333 |                                                 line,
334 |                                                 "Expected closing ')' in macro call",
335 |                                             );
336 |                                         }
337 |                                         _ => cursor += 1,
338 |                                     }
339 |                                 }
340 | 
341 |                                 let nested_call = call[start..cursor].to_owned();
342 |                                 let mut expansion = self.expand_macro(token.line, &nested_call);
343 | 
344 |                                 current_arg.lexeme.append(&mut expansion);
345 | 
346 |                                 // cursor is already incremented
347 |                                 continue;
348 |                             }
349 |                         }
350 |                         _ => {}
351 |                     }
352 | 
353 |                     if !is_arg_comma {
354 |                         if let Err(error) = current_arg.new_token(token.clone()) {
355 |                             report(ErrorType::Preprocessor, line, error);
356 |                         }
357 |                     }
358 |                }
359 |             }
360 | 
361 |             cursor += 1;
362 |         }
363 | 
364 |         self.macros.get(&name.lexeme).unwrap().expand(args)
365 |     }
366 | 
367 |     fn at_end(&self) -> bool {
368 |         self.current >= self.tokens.len()
369 |     }
370 | 
371 |     fn advance(&mut self) -> Token {
372 |         let token = self.peek();
373 |         self.current += 1;
374 |         token
375 |     }
376 | 
377 |     fn previous(&self) -> Token {
378 |         if self.current == 0 {
379 |             panic!("Tried to call previous() at start of file");
380 |         }
381 | 
382 |         self.tokens.get(self.current - 1).unwrap().to_owned()
383 |     }
384 | 
385 |     fn peek(&self) -> Token {
386 |         if self.at_end() {
387 |             panic!("Error: unexpected EOF");
388 |         }
389 | 
390 |         self.tokens.get(self.current).unwrap().to_owned()
391 |     }
392 | 
393 |     fn consume(&mut self, token_type: TokenType) -> Option<Token> {
394 |         let token = self.peek();
395 |         if token.token_type == token_type {
396 |             self.current += 1;
397 |             return Some(token);
398 |         }
399 | 
400 |         None
401 |     }
402 | }
403 | 


--------------------------------------------------------------------------------
/bml/src/scanner.rs:
--------------------------------------------------------------------------------
  1 | use std::collections::HashMap;
  2 | 
  3 | use crate::{token::Token, token_type::TokenType, logger::{ErrorType, report}};
  4 | 
  5 | pub struct Scanner {
  6 |     source: String,
  7 |     current: usize,
  8 |     line: usize,
  9 |     start: usize,
 10 |     tokens: Vec<Token>,
 11 |     keywords: HashMap<&'static str, TokenType>,
 12 |     swizzles: HashMap<char, TokenType>,
 13 | }
 14 | 
 15 | impl Scanner {
 16 |     pub fn from(source: String) -> Scanner {
 17 |         let mut keywords = HashMap::new();
 18 | 
 19 |         keywords.insert("if", TokenType::If);
 20 |         keywords.insert("else", TokenType::Else);
 21 |         keywords.insert("return", TokenType::Return);
 22 |         keywords.insert("give", TokenType::Give);
 23 |         keywords.insert("macro", TokenType::Macro);
 24 |         keywords.insert("repeat", TokenType::Repeat);
 25 |         keywords.insert("while", TokenType::While);
 26 | 
 27 |         keywords.insert("vec2", TokenType::Vec2);
 28 |         keywords.insert("vec3", TokenType::Vec3);
 29 |         keywords.insert("vec4", TokenType::Vec4);
 30 | 
 31 |         let mut swizzles = HashMap::new();
 32 | 
 33 |         swizzles.insert('x', TokenType::X);
 34 |         swizzles.insert('y', TokenType::Y);
 35 |         swizzles.insert('z', TokenType::Z);
 36 |         swizzles.insert('w', TokenType::W);
 37 | 
 38 |         swizzles.insert('r', TokenType::X);
 39 |         swizzles.insert('g', TokenType::Y);
 40 |         swizzles.insert('b', TokenType::Z);
 41 |         swizzles.insert('a', TokenType::W);
 42 | 
 43 |         Scanner {
 44 |             source,
 45 |             current: 0,
 46 |             line: 1,
 47 |             start: 0,
 48 |             tokens: vec![],
 49 |             keywords,
 50 |             swizzles,
 51 |         }
 52 |     }
 53 | 
 54 |     pub fn scan(mut self) -> Vec<Token> {
 55 |         loop {
 56 |             if self.at_end() {
 57 |                 break;
 58 |             }
 59 |             self.start = self.current;
 60 |             self.scan_token();
 61 |         }
 62 | 
 63 |         self.tokens
 64 |             .push(Token::new(TokenType::Eof, String::new(), self.line));
 65 |         self.tokens
 66 |     }
 67 | 
 68 |     fn scan_token(&mut self) {
 69 |         let c = self.advance();
 70 |         match c {
 71 |             '[' => self.add_token(TokenType::LeftSquare),
 72 |             ']' => self.add_token(TokenType::RightSquare),
 73 |             '(' => self.add_token(TokenType::LeftParen),
 74 |             ')' => self.add_token(TokenType::RightParen),
 75 |             '{' => self.add_token(TokenType::LeftBracket),
 76 |             '}' => self.add_token(TokenType::RightBracket),
 77 |             ';' => self.add_token(TokenType::Semi),
 78 |             ',' => self.add_token(TokenType::Comma),
 79 |             '-' => self.add_token(TokenType::Minus),
 80 |             '+' => self.add_token(TokenType::Plus),
 81 |             '*' => self.add_token(TokenType::Star),
 82 |             '/' => self.add_token(TokenType::Slash),
 83 |             '!' => {
 84 |                 if self.match_lexeme('=') {
 85 |                     self.add_token(TokenType::NotEquals)
 86 |                 } else {
 87 |                     self.unexpected_char(c);
 88 |                 }
 89 |             }
 90 |             '=' => {
 91 |                 let token = if self.match_lexeme('=') {
 92 |                     TokenType::EqualsEquals
 93 |                 } else {
 94 |                     TokenType::Equals
 95 |                 };
 96 |                 self.add_token(token);
 97 |             }
 98 |             '<' => {
 99 |                 let token = if self.match_lexeme('=') {
100 |                     TokenType::LessThanEquals
101 |                 } else {
102 |                     TokenType::LessThan
103 |                 };
104 |                 self.add_token(token);
105 |             }
106 |             '>' => {
107 |                 let token = if self.match_lexeme('=') {
108 |                     TokenType::GreaterThanEquals
109 |                 } else {
110 |                     TokenType::GreaterThan
111 |                 };
112 |                 self.add_token(token);
113 |             }
114 |             '#' => {
115 |                 // single line comment, skip line
116 |                 while !self.at_end() && self.peek().unwrap() != '\n' {
117 |                     self.advance();
118 |                 }
119 |             }
120 |             ' ' | '\r' | '\t' => {}
121 |             '\n' => self.line += 1,
122 |             '.' => self.swazzle(),
123 |             _ => {
124 |                 if c.is_digit(10) {
125 |                     self.number();
126 |                 } else if c.is_alphabetic() {
127 |                     self.identifier();
128 |                 } else {
129 |                     self.unexpected_char(c);
130 |                 }
131 |             }
132 |         }
133 |     }
134 |     
135 |     fn unexpected_char(&self, c: char) -> ! {
136 |         report(ErrorType::Scanner, self.line, format!("Unexpected character '{}'", c))
137 |     }
138 | 
139 |     fn swazzle(&mut self) {
140 |         self.add_token(TokenType::Dot);
141 | 
142 |         loop {
143 |             if let Some(next) = self.peek() {
144 |                 if let Some(&swazzler) = self.swizzles.get(&next) {
145 |                     self.start = self.current;
146 | 
147 |                     self.advance();
148 |                     self.add_token(swazzler);
149 | 
150 |                     continue;
151 |                 }
152 |             }
153 | 
154 |             break;
155 |         }
156 |     }
157 | 
158 |     fn identifier(&mut self) {
159 |         loop {
160 |             if self.at_end() || (!self.peek().unwrap().is_alphanumeric() && self.peek().unwrap() != '_') {
161 |                 break;
162 |             }
163 | 
164 |             self.advance();
165 |         }
166 | 
167 |         let text = self.source[self.start..self.current].to_string();
168 |         if let Some(&keyword) = self.keywords.get(text.as_str()) {
169 |             self.add_token(keyword);
170 |         } else {
171 |             self.add_token(TokenType::Identifier)
172 |         }
173 |     }
174 | 
175 |     fn number(&mut self) {
176 |         self.consume_digits();
177 | 
178 |         match (self.peek(), self.peek_next()) {
179 |             (Some('.'), Some(next)) => {
180 |                 if next.is_digit(10) {
181 |                     self.advance();
182 | 
183 |                     self.consume_digits();
184 |                 }
185 |             },
186 |             _ => {}
187 |         }
188 | 
189 |         self.add_token(TokenType::Number)
190 |     }
191 | 
192 |     fn consume_digits(&mut self) {
193 |         loop {
194 |             if self.at_end() || !self.peek().unwrap().is_digit(10) {
195 |                 break
196 |             }
197 | 
198 |             self.advance();
199 |         }
200 |     }
201 | 
202 |     fn peek_next(&self) -> Option<char> {
203 |         if self.current + 1 >= self.source.len() { 
204 |             None
205 |         } else {
206 |             Some(self.char_at(self.current + 1))
207 |         }
208 |     }
209 | 
210 |     fn peek(&self) -> Option<char> {
211 |         if self.at_end() {
212 |             None
213 |         } else {
214 |             Some(self.char_at(self.current))
215 |         }
216 |     }
217 | 
218 |     fn match_lexeme(&mut self, expected: char) -> bool {
219 |         if self.at_end() {
220 |             return false;
221 |         }
222 |         if self.char_at(self.current) != expected {
223 |             return false;
224 |         }
225 | 
226 |         self.current += 1;
227 |         true
228 |     }
229 | 
230 |     fn add_token(&mut self, token_type: TokenType) {
231 |         self.tokens.push(Token::new(
232 |             token_type,
233 |             self.source[self.start..self.current].to_string(),
234 |             self.line,
235 |         ));
236 |     }
237 | 
238 |     fn char_at(&self, n: usize) -> char {
239 |         self.source.chars().nth(n).unwrap()
240 |     }
241 | 
242 |     fn advance(&mut self) -> char {
243 |         let ch = self.char_at(self.current);
244 |         self.current += 1;
245 |         ch
246 |     }
247 | 
248 |     fn at_end(&self) -> bool {
249 |         self.current >= self.source.len()
250 |     }
251 | }
252 | 


--------------------------------------------------------------------------------
/bml/src/token.rs:
--------------------------------------------------------------------------------
 1 | use crate::token_type::TokenType;
 2 | 
 3 | #[derive(Debug, Clone, PartialEq, Eq)]
 4 | pub struct Token {
 5 |     pub token_type: TokenType,
 6 |     pub lexeme: String,
 7 |     pub line: usize,
 8 | }
 9 | 
10 | impl Token {
11 |     pub fn new(token_type: TokenType, lexeme: String, line: usize) -> Token {
12 |         Token {
13 |             token_type,
14 |             lexeme,
15 |             line,
16 |         }
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/bml/src/token_type.rs:
--------------------------------------------------------------------------------
 1 | #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 2 | pub enum TokenType {
 3 |     // single-char tokens
 4 |     LeftParen,
 5 |     RightParen,
 6 |     Comma,
 7 |     LeftSquare,
 8 |     RightSquare,
 9 |     LeftBracket,
10 |     RightBracket,
11 |     Semi,
12 |     Equals,
13 | 
14 |     // one-or-two char tokens
15 |     Plus,
16 |     Minus,
17 |     Slash,
18 |     Star,
19 |     NotEquals,
20 |     EqualsEquals,
21 |     GreaterThan,
22 |     LessThan,
23 |     LessThanEquals,
24 |     GreaterThanEquals,
25 | 
26 |     // swizzling
27 |     Dot,
28 |     X,
29 |     Y,
30 |     Z,
31 |     W,
32 | 
33 |     // keywords
34 |     If,
35 |     Else,
36 |     Return,
37 |     Give,
38 |     Macro,
39 |     Repeat,
40 |     While,
41 | 
42 |     // literals
43 |     Number,
44 |     Vec2,
45 |     Vec3,
46 |     Vec4,
47 | 
48 |     // identifiers
49 |     Identifier,
50 | 
51 |     Eof,
52 | }
53 | 


--------------------------------------------------------------------------------
/slackbot/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "bml-slackbot",
 3 |     "version": "1.0.0",
 4 |     "description": "Programmatically manipulate and generate images using the Buffer Manipulation Language",
 5 |     "main": "build/app.js",
 6 |     "scripts": {
 7 |         "dev": "ts-node-dev --respawn --transpile-only src/app.ts",
 8 |         "prod": "tsc -p . && node ./build/src/app.js",
 9 |         "clean": "rm -rf build"
10 |     },
11 |     "license": "ISC",
12 |     "dependencies": {
13 |         "@slack/bolt": "^3.8.1",
14 |         "axios": "^0.24.0",
15 |         "dotenv": "^10.0.0",
16 |         "html-escaper": "^3.0.3"
17 |     },
18 |     "devDependencies": {
19 |         "@types/html-escaper": "^3.0.0",
20 |         "@types/node": "^17.0.2",
21 |         "nodemon": "^2.0.15",
22 |         "ts-node": "^10.4.0",
23 |         "typescript": "^4.5.4"
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/slackbot/src/Domains.ts:
--------------------------------------------------------------------------------
 1 | import fs from 'fs'
 2 | 
 3 | export type Domain = { 
 4 |     authorId: string,
 5 |     desc: string,
 6 |     script: string
 7 | }
 8 | 
 9 | export type DomainsDB = {
10 |     [key: string]: Domain
11 | }
12 | 
13 | export class Domains {
14 |     private domains: DomainsDB
15 |     private path: string
16 | 
17 |     private flush(): Promise<void> {
18 |         return new Promise((resolve, reject) => {
19 |             fs.writeFile(this.path, JSON.stringify(this.domains), (err) => {
20 |                 if (err) throw reject(err)
21 |                 resolve()
22 |             })
23 |         })
24 |     }
25 | 
26 |     constructor(path: string) {
27 |         this.path = path
28 |         try {
29 |             this.domains = JSON.parse(fs.readFileSync(path).toString()) as DomainsDB
30 |         } catch (err) {
31 |             throw new Error(`Error when initializing Domains DB: ${err}`)
32 |         }
33 |     }
34 | 
35 |     getAll(): [string, Domain][] {
36 |         return Object.entries(this.domains)
37 |     }
38 | 
39 |     get(name: string): Domain | undefined {
40 |         return this.domains[name]
41 |     }
42 | 
43 |     ownsDomain(domain: string, authorId: string): boolean {
44 |         return this.domains[domain]?.authorId == authorId
45 |     }
46 | 
47 |     create(domain: string, desc: string, authorId: string, script: string) {
48 |         this.domains[domain] = {
49 |             authorId,
50 |             script,
51 |             desc
52 |         }
53 | 
54 |         this.flush()
55 |     }
56 | 
57 |     updateDomain(domain: string, script: string, desc?: string) {
58 |         this.domains[domain].script = script
59 | 
60 |         if (desc) {
61 |             this.domains[domain].desc = desc
62 |         }
63 | 
64 |         this.flush()
65 |     }
66 | }


--------------------------------------------------------------------------------
/slackbot/src/app.ts:
--------------------------------------------------------------------------------
  1 | import { App, LogLevel } from '@slack/bolt'
  2 | import axios, { AxiosResponse } from 'axios'
  3 | import * as fs from 'fs'
  4 | import { spawn } from 'child_process'
  5 | import { unescape } from 'html-escaper'
  6 | import { ChatPostEphemeralResponse, ChatPostMessageResponse, FilesUploadResponse } from '@slack/web-api'
  7 | import { Domains } from './Domains'
  8 | import { Domain } from 'domain'
  9 | import { stringify } from 'querystring'
 10 | 
 11 | const { SC_TOKEN, SLACK_TOKEN, SLACK_SIGNING_SECRET } = JSON.parse(fs.readFileSync('auth.json').toString())
 12 | 
 13 | const app = new App({
 14 |     token: SLACK_TOKEN,
 15 |     signingSecret: SLACK_SIGNING_SECRET,
 16 |     logLevel: LogLevel.DEBUG
 17 | })
 18 | 
 19 | const BOT_ID = 'U02RMPDLXDH'
 20 | const CHANNEL_ID = 'C02RJRTK8LV'
 21 | const TMP_IMAGE_DOWNLOAD = './tmp/tmp.png'
 22 | const TMP_SCRIPT_DOWNLOAD = './tmp/script.bml'
 23 | 
 24 | const PORT = 3004
 25 | 
 26 | const domains = new Domains('./domains.json')
 27 | 
 28 | enum Cmd {
 29 |     Eval = 'eval',
 30 |     Process = 'process',
 31 |     New = 'new'
 32 | }
 33 | 
 34 | type Args = {
 35 |     cmd: Cmd,
 36 |     width: number,
 37 |     height: number,
 38 |     frameCount: number,
 39 |     desc?: string,
 40 |     domain?: string
 41 | }
 42 | 
 43 | /**
 44 |  * Download given image from URL to local filesystem 
 45 |  * @param url URI for image to download
 46 |  * @param path Path to write downloaded image to
 47 |  */
 48 | async function downloadImage(url: string, path: string) {
 49 |     const response = await axios({
 50 |         url,
 51 |         method: 'get',
 52 |         responseType: 'stream',
 53 |         headers: {
 54 |             Authorization: `Bearer ${SLACK_TOKEN}`
 55 |         }
 56 |     })
 57 | 
 58 |     response.data.pipe(fs.createWriteStream(path))
 59 | }
 60 | 
 61 | /**
 62 |  * Run BML binary with given arguments
 63 |  * @param args Command line arguments for BML
 64 |  * @returns TODO: generator for each line of stdout
 65 |  */
 66 | async function runBML(args: string[]): Promise<string> {
 67 |     const bml = spawn('../bml/target/release/bml', args)
 68 | 
 69 |     return new Promise((resolve, reject) => {
 70 |         let output = ''
 71 | 
 72 |         bml.stdout.on('data', (data: Buffer) => { output += data.toString() })
 73 |         bml.stderr.on('data', (data: Buffer) => { output += data.toString() })
 74 | 
 75 |         bml.on('exit', (code, signal) => {
 76 |             if (code == 0) resolve(output)
 77 |             reject(output)
 78 |         })
 79 |     })
 80 | }
 81 | 
 82 | /**
 83 |  * Fetches last image (PNG) in BML Slack channel
 84 |  * @returns Promise of the URL for the last sent image
 85 |  */
 86 | async function lastImage(): Promise<string> {
 87 |     let history = await app.client.conversations.history({
 88 |         channel: CHANNEL_ID
 89 |     })
 90 | 
 91 |     for (; ;) {
 92 |         for (let msg of history.messages || []) {
 93 |             if (msg.files && msg.files[0].filetype == 'png') {
 94 |                 return msg.files[0].url_private_download!
 95 |             }
 96 |         }
 97 | 
 98 |         if (history.response_metadata?.next_cursor) {
 99 |             history = await app.client.conversations.history({
100 |                 channel: CHANNEL_ID,
101 |                 cursor: history.response_metadata.next_cursor!
102 |             })
103 |             continue
104 |         }
105 | 
106 |         // no more pages left
107 |         break
108 |     }
109 | 
110 |     throw new Error('couldn\'t find image in channel history')
111 | }
112 | 
113 | async function writeFile(path: string, text: string): Promise<void> {
114 |     return new Promise((resolve, reject) => {
115 |         fs.writeFile(path, text, (err: any) => {
116 |             if (err) reject(err)
117 |             resolve()
118 |         })
119 |     })
120 | }
121 | 
122 | async function reply(text: string, threadTs: string): Promise<ChatPostMessageResponse> {
123 |     return app.client.chat.postMessage({
124 |         channel: CHANNEL_ID,
125 |         text,
126 |         thread_ts: threadTs
127 |     })
128 | }
129 | 
130 | async function sayEphemeral(text: string, user: string): Promise<ChatPostEphemeralResponse> {
131 |     return app.client.chat.postEphemeral({
132 |         channel: CHANNEL_ID,
133 |         text,
134 |         user
135 |     })
136 | }
137 | 
138 | async function replyWithImage(path: string, threadTs: string): Promise<FilesUploadResponse> {
139 |     return app.client.files.upload({
140 |         channels: CHANNEL_ID,
141 |         initial_comment: 'Manipulated image',
142 |         file: fs.createReadStream(path),
143 |         thread_ts: threadTs
144 |     })
145 | }
146 | 
147 | async function scPay(receiverId: string, cents: number, forMessage: string): Promise<AxiosResponse<any, any>> {
148 |     return axios.post('https://misguided.enterprises/scales/api/pay', {
149 |         receiverId: receiverId,
150 |         cents: cents,
151 |         for: forMessage
152 |     })
153 | }
154 | 
155 | function parseArgs(args: string): Args {
156 |     let result: Args = {
157 |         cmd: null,
158 |         width: 100,
159 |         height: 100,
160 |         frameCount: 1,
161 |         desc: null,
162 |         domain: null
163 |     }
164 | 
165 |     const cmd = args.split(' ')[0]
166 | 
167 |     switch (cmd) {
168 |         case 'process':
169 |         case '':
170 |             result.cmd = Cmd.Process
171 |             break
172 |         case 'eval':
173 |             result.cmd = Cmd.Eval
174 |             break
175 |         case 'new':
176 |             result.cmd = Cmd.New
177 |             break
178 |         default:
179 |             throw new Error(`Expected no command specified/'process', 'eval', or 'new', got '${cmd}'`)
180 |     }
181 | 
182 |     const flags = args.match(/\w+?=\w+/g)
183 | 
184 |     for (const flag of flags || []) {
185 |         const parts = flag.split('=')
186 | 
187 |         const name = parts[0]
188 | 
189 |         const value = parts[1]
190 | 
191 |         const valueAsNum = (key: string) => {
192 |             const v = parseInt(value)
193 | 
194 |             if (isNaN(v)) {
195 |                 throw new Error(`Expected number for '${key}' flag, got '${value}'`)
196 |             }
197 | 
198 |             return v
199 |         }
200 | 
201 |         switch (name) {
202 |             case 'd':
203 |             case 'domain':
204 |                 result.domain = value
205 |                 break
206 |             case 'w':
207 |             case 'width':
208 |                 result.width = valueAsNum('width')
209 |                 break
210 |             case 'h':
211 |             case 'height':
212 |                 result.height = valueAsNum('height')
213 |                 break
214 |             case 'f':
215 |             case 'frame_count':
216 |                 result.frameCount = valueAsNum('frame_count')
217 |                 break
218 |             case 'desc':
219 |                 result.desc = value
220 |                 break
221 |         }
222 |     }
223 | 
224 |     return result
225 | }
226 | 
227 | /**
228 |  * Helper for unescaping HTML escape codes and links
229 |  * (frag.xyz -> <http://frag.xyz|frag.xyz>) when parsing
230 |  * user scripts from Bolt
231 |  * @param text Text to be escaped
232 |  * @returns Escaped text
233 |  */
234 | function unescapeSlack(text: string): string {
235 |     return unescape(text.replaceAll(/<http\:\/\/([^|]+)\|(.+)>/g, '$1'))
236 | }
237 | 
238 | app.command('/domain', async ({ command, ack, respond }) => {
239 |     await ack()
240 | 
241 |     const name = command.text.trim()
242 | 
243 |     if (name == '') {
244 |         respond('Expected /domain <name>')
245 |         return
246 |     }
247 | 
248 |     const domain = domains.get(name)
249 | 
250 |     if (domain == undefined) {
251 |         respond(`No-one currently owns the domain '${name}' (but you could buy your own for just *20 sc: sc!* (or, for now, for free with /buydomain <name>!))`)
252 |         return
253 |     }
254 | 
255 |     const message = `\`${name}\`: ${domain.desc}\n${
256 |         domain.script == '' 
257 |             ? '<No script currently exists>'
258 |             : `\`\`\`${domain.script}\`\`\``
259 |     }`
260 | 
261 |     await respond(message)
262 | })
263 | 
264 | app.command('/domains', async ({ ack, respond }) => {
265 |     await ack()
266 | 
267 |     const list = domains.getAll()
268 | 
269 |     const message = list.length 
270 |         ? list.map(([name, dom]) => `${name}: owned by <@${dom.authorId}>, "${dom.desc}"`).join('\n')
271 |         : "Currently no-one owns any domains! (but you could buy for one for only *20 :sc: big ones!* (or for now just with /buydomain <name> for free)"
272 | 
273 |     await respond(message)
274 | })
275 | 
276 | app.command('/buydomain', async ({ command, ack, respond }) => {
277 |     await ack()
278 | 
279 |     const { user_id, text } = command
280 | 
281 |     // /buy <domain>
282 |     const parts = text.match(/(\w+) ["“](.*)["”]/)
283 | 
284 |     console.log(text, parts)
285 | 
286 |     if (parts?.length < 3) {
287 |         respond('Expected /buy <domain> "What this script does"')
288 |         return
289 |     }
290 | 
291 |     const name = parts[1].trim()
292 | 
293 |     const domain = domains.get(name)
294 | 
295 |     if (domain?.authorId == user_id) {
296 |         respond('You already own this domain!')
297 |         return
298 |     }
299 | 
300 |     const desc = parts[2].trim()
301 | 
302 |     try {
303 |         // const result = scPay(user_id, 20);
304 |         await respond(`You now own the script domain ${name}!`)
305 | 
306 |         domains.create(name, desc, user_id, '')
307 |     } catch (error: any) {
308 |         // respond(`You need at least **:sc: 20** to buy the domain ${text}, but only have ${error.balance} in your balance`)
309 |     }
310 | })
311 | 
312 | app.message(async ({ message }) => {
313 |     const text = (message as any).text as string
314 | 
315 |     console.log('received message:', message)
316 | 
317 |     const ts = (message as any).thread_ts || message.ts
318 |     const authorId = (message as any).user
319 | 
320 |     const messageRe = new RegExp(`<@${BOT_ID}>([^\`]+)(?:\`\`\`([^\`]*)\`\`\`)?`)
321 |     const groups = text.match(messageRe)
322 | 
323 |     // return if doesn't match
324 |     if (!groups) {
325 |         console.log('Returning')
326 |         return
327 |     }
328 | 
329 |     const argsString = groups[1].trim()
330 | 
331 |     let args: Args
332 | 
333 |     try {
334 |         args = parseArgs(argsString)
335 |     } catch (error: any) {
336 |         await sayEphemeral(error.message, authorId)
337 |         return
338 |     }
339 | 
340 |     console.log(groups)
341 | 
342 |     let script = groups[2] ? unescapeSlack(groups[2].trim()) : null
343 | 
344 |     console.log('SCRIPT', script)
345 | 
346 |     if (script == undefined || script == '') {
347 |         if (args.domain == null) {
348 |             await sayEphemeral('Expected non-empty script code block or domain (d=<domian> or domain=<domain>), got neither', authorId)
349 |             return
350 |         }
351 | 
352 |         const domain = domains.get(args.domain)
353 | 
354 |         if (domain != null) {
355 |             if (domain.script == '') {
356 |                 await reply(`'${args.domain}' is owned by <@${domain.authorId}>, but currently has no assigned script!`, authorId)
357 |                 return
358 |             }
359 | 
360 |             script = domain.script
361 |         } else {
362 |             await sayEphemeral(`No-one owns the domain '${args.domain}' (but you could get it for just **20 :sc:** :eyes:)`, authorId)
363 |             return
364 |         }
365 |     }
366 | 
367 |     writeFile(TMP_SCRIPT_DOWNLOAD, script)
368 | 
369 |     console.log(`HANDLING COMMAND: ${args.cmd}`)
370 |     switch (args.cmd) {
371 |         case Cmd.Eval: {
372 |             try {
373 |                 const result = await runBML(['eval', TMP_SCRIPT_DOWNLOAD])
374 |                 reply(`\`\`\`${result}\`\`\``, ts)
375 |             } catch (err) {
376 |                 reply(`Error: \`\`\`${err}\`\`\``, ts)
377 |             }
378 | 
379 |             break
380 |         }
381 | 
382 |         case Cmd.Process: {
383 |             const url = await lastImage()
384 | 
385 |             await downloadImage(url, TMP_IMAGE_DOWNLOAD)
386 | 
387 |             try {
388 |                 const output = `${ts}.${args.frameCount > 1 ? 'gif' : 'png'}`
389 |                 await runBML(['process', TMP_SCRIPT_DOWNLOAD, TMP_IMAGE_DOWNLOAD, args.frameCount.toString(), output])
390 |                 replyWithImage(output, ts)
391 |             } catch (err) {
392 |                 reply(`Error: \`\`\`${err}\`\`\``, ts)
393 |             }
394 | 
395 |             break
396 |         }
397 | 
398 |         case Cmd.New: {
399 |             try {
400 |                 const output = `${ts}.${args.frameCount > 1 ? 'gif' : 'png'}`
401 |                 await runBML(['new', TMP_SCRIPT_DOWNLOAD, args.width.toString(), args.height.toString(), args.frameCount.toString(), output])
402 |                 replyWithImage(output, ts)
403 |             } catch (err) {
404 |                 reply(`Error: \`\`\`${err}\`\`\``, ts)
405 |                 return
406 |             }
407 | 
408 |             break
409 |         }
410 |     }
411 | 
412 |     // if new script was given and domain specified
413 |     if (args.domain != null && script != null) {
414 |         if (!domains.ownsDomain(args.domain, authorId)) {
415 |             reply(`listen here whippersnapper, you don't even own the domain "${args.domain}" it is, however, available. if you want to buy it for 20:sc:, do /bml buy ${args.domain}`, ts)
416 |             return
417 |         }
418 | 
419 |         // reply(`we've associated it with your "${args.domain}" domain. now anyone can run <@${BOT_ID}> ${args.domain} anywhere in the slack, and I will grab the last image someone posted and "${args.domain}" it!`, ts)
420 | 
421 |         domains.updateDomain(args.domain, script)
422 | 
423 |         reply(`Updated script on domain ${args.domain}`, ts)
424 |     }
425 | })
426 | 
427 | ;(async () => {
428 |     await app.start(PORT)
429 |     console.log(`The Slack app has started!`)
430 | })()


--------------------------------------------------------------------------------
/slackbot/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "compilerOptions": {
 3 |         "module": "commonjs",
 4 |         "resolveJsonModule": true,
 5 |         "esModuleInterop": true,
 6 |         "target": "es6",
 7 |         "moduleResolution": "node",
 8 |         "sourceMap": true,
 9 |         "outDir": "build",
10 |         "sourceRoot": "src",
11 |         // "watch": true
12 |         "lib": [
13 |             "ES2021.String"
14 |         ]
15 |     },
16 |     "lib": [
17 |         "es2017"
18 |     ],
19 |     "include": [
20 |         "src/",
21 |         "auth.json",
22 |         "domains.json"
23 |     ]
24 | }


--------------------------------------------------------------------------------