@thi.ng/shader-ast-js 0.7.68 → 1.0.1

package/pool.js

@@ -0,0 +1,68 @@
+import { typedArray, } from "@thi.ng/api";
+import { outOfBounds } from "@thi.ng/errors/out-of-bounds";
+import { set } from "@thi.ng/vectors/set";
+import { setC2, setC3, setC4 } from "@thi.ng/vectors/setc";
+import { setN, setN2, setN3, setN4 } from "@thi.ng/vectors/setn";
+/**
+ * Manager for re-using pre-allocated memory for various vector ops. If the
+ * compiled shader program includes a `main()` function, the pools will be reset
+ * automatically when that `main` function executes. Otherwise, users **MUST**
+ * call the {@link CompileResult.__reset} manually each time before invoking a
+ * compiled entry point function.
+ *
+ * @remarks
+ * Currently, the default capacity for each vector type is fixed at 2048 items.
+ * That means a shader program can create up to this number of temporary objects
+ * (per fragment/invocation). Should this number be insufficient, please submit
+ * an issue and explain your use case. Thanks!
+ */
+export class Pool {
+    constructor(type, size, cap) {
+        this.size = size;
+        this.cap = cap;
+        this.index = 0;
+        this.mem = typedArray(type, cap * size);
+        this.items = new Array(cap);
+        for (let i = 0; i < cap; i++) {
+            this.items[i] = this.mem.subarray(i * size, i * size + size);
+        }
+        const next = () => {
+            if (this.index > this.items.length)
+                outOfBounds(this.index);
+            return this.items[this.index++];
+        };
+        let from;
+        let uniform;
+        switch (this.size) {
+            case 2:
+                from = (x, y) => setC2(next(), x, y);
+                uniform = (n) => setN2(next(), n);
+            case 3:
+                from = (x, y, z) => setC3(next(), x, y, z);
+                uniform = (n) => setN3(next(), n);
+            case 4:
+                from = (x, y, z, w) => setC4(next(), x, y, z, w);
+                uniform = (n) => setN4(next(), n);
+            default:
+                from = (...args) => set(next(), args);
+                uniform = (n) => setN(next(), n);
+        }
+        this.next = next;
+        this.from = from;
+        this.uniform = uniform;
+    }
+    reset() {
+        this.index = 0;
+        return this;
+    }
+}
+const CAP = 2048;
+export const POOL_VEC2 = new Pool("f32", 2, CAP);
+export const POOL_VEC3 = new Pool("f32", 3, CAP);
+export const POOL_VEC4 = new Pool("f32", 4, CAP);
+export const POOL_IVEC2 = new Pool("i32", 2, CAP);
+export const POOL_IVEC3 = new Pool("i32", 3, CAP);
+export const POOL_IVEC4 = new Pool("i32", 4, CAP);
+export const POOL_UVEC2 = new Pool("u32", 2, CAP);
+export const POOL_UVEC3 = new Pool("u32", 3, CAP);
+export const POOL_UVEC4 = new Pool("u32", 4, CAP);

package/runtime.d.ts

@@ -1,41 +1,54 @@
-import type { Fn } from "@thi.ng/api";
+import type { Fn, UIntArray } from "@thi.ng/api";
 import { type IntBuffer } from "@thi.ng/pixel/int";
 import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
+export interface RenderPixelOpts {
+    x?: number;
+    y?: number;
+    w?: number;
+    h?: number;
+    bufW: number;
+    bufH: number;
+    offsetX?: number;
+    offsetY?: number;
+    imgH?: number;
+    /**
+     * Format conversion from float RGBA to packed integer.
+     */
+    fmt: Fn<ReadonlyVec, number>;
+}
+export declare const rgbaBgra8888: (rgba: ReadonlyVec) => number;
+export declare const rgbaRgb565: (rgba: ReadonlyVec) => number;
 /**
  * Low-level function used by {@link canvasRenderer} and {@link renderBuffer}.
- * Applies shader function `fn` to each pixel in the given region of the `u32`
- * raw ABGR buffer (a `Uint32Array`). The region is defined by the top-left `x`,
- * `y` coords and `w`, `h` dimensions. The remaining parameters `bufW`, `bufH`,
- * `bufOffsetX`, `bufOffsetY` and `imgH` are used to define the actual location
- * of the given buffer in the full image to be computed and to support use cases
- * where the target array only defines a sub-region of the full image (e.g. when
- * splitting rendering over multiple workers, each with their own buffer).
+ * Applies shader function `fn` to each pixel in the given region of the
+ * `pixels` buffer (e.g. a `Uint32Array`). The render region is defined via
+ * options. The top-left `x`, `y` coords and `w`, `h` dimensions. The remaining
+ * parameters `bufW`, `bufH`, `bufOffsetX`, `bufOffsetY` and `imgH` are used to
+ * define the actual location of the given buffer in the full image to be
+ * computed and to support use cases where the target array only defines a
+ * sub-region of the full image (e.g. when splitting rendering over multiple
+ * workers, each with their own buffer).
  *
  * @param fn -
- * @param u32 -
- * @param bufW -
- * @param bufH -
- * @param x -
- * @param y -
- * @param w -
- * @param h -
- * @param bufOffsetX -
- * @param bufOffsetY -
- * @param imgH -
+ * @param pixels -
+ * @param opts
  */
-export declare const renderPixels: (fn: Fn<ReadonlyVec, Vec>, u32: Uint32Array, bufW: number, bufH: number, x: number, y: number, w?: number, h?: number, bufOffsetX?: number, bufOffsetY?: number, imgH?: number) => Uint32Array;
+export declare const renderPixels: (fn: Fn<ReadonlyVec, Vec>, pixels: UIntArray, { x, y, w, h, bufW, bufH, offsetX, offsetY, imgH, fmt }: RenderPixelOpts) => UIntArray;
 /**
  * Takes a
  * [`IntBuffer`](https://docs.thi.ng/umbrella/pixel/classes/IntBuffer.html)
- * pixel buffer from thi.ng/pixel w/
- * [`ABGR8888`](https://docs.thi.ng/umbrella/pixel/variables/ABGR8888.html)
- * format, an optional buffer local region defined by `x`, `y`, `w`, `h` and
- * applies shader function `fn` to each pixel in that region (or full buffer by
- * default).
+ * pixel buffer from thi.ng/pixel, and options to define a buffer-local render
+ * region. Applies shader function `fn` to each pixel in that region (or the
+ * full buffer by default).
+ *
+ * @remarks
+ * In case the buffer only defines a sub-region of a larger image,
+ * {@link RenderPixelOpts.offsetX}, {@link RenderPixelOpts.offsetY} and
+ * {@link RenderPixelOpts.imgH} can be given to configure the location and full
+ * image height.
  *
- * In case the buffer only defines a sub-region of a larger image, `bufOffsetX`,
- * `bufOffsetY` and `imgH` can be given to configure the location and full image
- * height.
+ * The default target pixel format is `ABGR8888` using {@link rgbaBgra8888} as
+ * default {@link RenderPixelOpts.fmt} conversion.
  *
  * @param fn -
  * @param buf -
@@ -47,7 +60,7 @@ export declare const renderPixels: (fn: Fn<ReadonlyVec, Vec>, u32: Uint32Array,
  * @param bufOffsetY -
  * @param imgH -
  */
-export declare const renderBuffer: (fn: Fn<ReadonlyVec, Vec>, buf: IntBuffer, x?: number, y?: number, w?: number, h?: number, bufOffsetX?: number, bufOffsetY?: number, imgH?: number) => IntBuffer;
+export declare const renderBuffer: (fn: Fn<ReadonlyVec, Vec>, buf: IntBuffer, opts?: Partial<RenderPixelOpts>) => IntBuffer;
 /**
  * Higher order function accepting an `HTMLCanvasElement` and returning a render
  * function which accepts the following parameters:

package/runtime.js

@@ -1,62 +1,62 @@
-import { assert } from "@thi.ng/errors/assert";
 import { clamp, clamp01 } from "@thi.ng/math/interval";
-import { ABGR8888 } from "@thi.ng/pixel/format/abgr8888";
 import { intBufferFromCanvas } from "@thi.ng/pixel/int";
-const rgba2bgra = (rgba) => ((clamp01(rgba[0]) * 255.5) << 0) |
+export const rgbaBgra8888 = (rgba) => ((clamp01(rgba[0]) * 255.5) << 0) |
     ((clamp01(rgba[1]) * 255.5) << 8) |
     ((clamp01(rgba[2]) * 255.5) << 16) |
     ((clamp01(rgba[3]) * 255.5) << 24);
+export const rgbaRgb565 = (rgba) => (((clamp01(rgba[0]) * 255.5) & 0xf8) << 8) |
+    (((clamp01(rgba[1]) * 255.5) & 0xfc) << 3) |
+    (((clamp01(rgba[2]) * 255.5) & 0xf8) >> 3);
 const clampCoord = (x, maxW, w) => w !== undefined ? Math.min(x + w, maxW) : maxW;
 /**
  * Low-level function used by {@link canvasRenderer} and {@link renderBuffer}.
- * Applies shader function `fn` to each pixel in the given region of the `u32`
- * raw ABGR buffer (a `Uint32Array`). The region is defined by the top-left `x`,
- * `y` coords and `w`, `h` dimensions. The remaining parameters `bufW`, `bufH`,
- * `bufOffsetX`, `bufOffsetY` and `imgH` are used to define the actual location
- * of the given buffer in the full image to be computed and to support use cases
- * where the target array only defines a sub-region of the full image (e.g. when
- * splitting rendering over multiple workers, each with their own buffer).
+ * Applies shader function `fn` to each pixel in the given region of the
+ * `pixels` buffer (e.g. a `Uint32Array`). The render region is defined via
+ * options. The top-left `x`, `y` coords and `w`, `h` dimensions. The remaining
+ * parameters `bufW`, `bufH`, `bufOffsetX`, `bufOffsetY` and `imgH` are used to
+ * define the actual location of the given buffer in the full image to be
+ * computed and to support use cases where the target array only defines a
+ * sub-region of the full image (e.g. when splitting rendering over multiple
+ * workers, each with their own buffer).
  *
  * @param fn -
- * @param u32 -
- * @param bufW -
- * @param bufH -
- * @param x -
- * @param y -
- * @param w -
- * @param h -
- * @param bufOffsetX -
- * @param bufOffsetY -
- * @param imgH -
+ * @param pixels -
+ * @param opts
  */
-export const renderPixels = (fn, u32, bufW, bufH, x, y, w, h, bufOffsetX = 0, bufOffsetY = 0, imgH = bufH) => {
-    const frag = [];
-    x = clamp(x, 0, bufW);
-    y = clamp(y, 0, bufH);
+export const renderPixels = (fn, pixels, { x, y, w, h, bufW, bufH, offsetX, offsetY, imgH, fmt }) => {
+    offsetX = offsetX || 0;
+    offsetY = offsetY || 0;
+    imgH = (imgH || bufH) - 1 - offsetY;
+    x = clamp(x || 0, 0, bufW);
+    y = clamp(y || 0, 0, bufH);
     const x2 = clampCoord(x, bufW, w);
     const y2 = clampCoord(y, bufH, h);
+    const fragCoord = [];
     for (let yy = y; yy < y2; yy++) {
-        frag[1] = imgH - 1 - yy - bufOffsetY;
+        fragCoord[1] = imgH - yy;
         let i = yy * bufW + x;
         for (let xx = x; xx < x2; xx++) {
-            frag[0] = xx + bufOffsetX;
-            u32[i++] = rgba2bgra(fn(frag));
+            fragCoord[0] = xx + offsetX;
+            pixels[i++] = fmt(fn(fragCoord));
         }
     }
-    return u32;
+    return pixels;
 };
 /**
  * Takes a
  * [`IntBuffer`](https://docs.thi.ng/umbrella/pixel/classes/IntBuffer.html)
- * pixel buffer from thi.ng/pixel w/
- * [`ABGR8888`](https://docs.thi.ng/umbrella/pixel/variables/ABGR8888.html)
- * format, an optional buffer local region defined by `x`, `y`, `w`, `h` and
- * applies shader function `fn` to each pixel in that region (or full buffer by
- * default).
+ * pixel buffer from thi.ng/pixel, and options to define a buffer-local render
+ * region. Applies shader function `fn` to each pixel in that region (or the
+ * full buffer by default).
+ *
+ * @remarks
+ * In case the buffer only defines a sub-region of a larger image,
+ * {@link RenderPixelOpts.offsetX}, {@link RenderPixelOpts.offsetY} and
+ * {@link RenderPixelOpts.imgH} can be given to configure the location and full
+ * image height.
  *
- * In case the buffer only defines a sub-region of a larger image, `bufOffsetX`,
- * `bufOffsetY` and `imgH` can be given to configure the location and full image
- * height.
+ * The default target pixel format is `ABGR8888` using {@link rgbaBgra8888} as
+ * default {@link RenderPixelOpts.fmt} conversion.
  *
  * @param fn -
  * @param buf -
@@ -68,9 +68,15 @@ export const renderPixels = (fn, u32, bufW, bufH, x, y, w, h, bufOffsetX = 0, bu
  * @param bufOffsetY -
  * @param imgH -
  */
-export const renderBuffer = (fn, buf, x = 0, y = 0, w, h, bufOffsetX = 0, bufOffsetY = 0, imgH = buf.height) => {
-    assert(buf.format === ABGR8888, `invalid buffer pixel format`);
-    renderPixels(fn, buf.data, buf.width, buf.height, x, y, w, h, bufOffsetX, bufOffsetY, imgH);
+export const renderBuffer = (fn, buf, opts) => {
+    renderPixels(fn, buf.data, {
+        fmt: rgbaBgra8888,
+        bufW: buf.width,
+        bufH: buf.height,
+        x: 0,
+        y: 0,
+        ...opts,
+    });
     return buf;
 };
 /**
@@ -87,7 +93,7 @@ export const canvasRenderer = (canvas) => {
     const buf = intBufferFromCanvas(canvas);
     const data = new ImageData(canvas.width, canvas.height);
     return (fn, x = 0, y = 0, w = canvas.width, h = canvas.height) => {
-        renderBuffer(fn, buf, x, y, w, h);
+        renderBuffer(fn, buf, { x, y, w, h });
         buf.blitCanvas(canvas, { data });
     };
 };

package/target.js

@@ -31,22 +31,25 @@ const OP_IDS = {
     "<<": "lshift",
     ">>": "rshift",
 };
-const PRELUDE = [
-    "float",
-    "int",
-    "uint",
+const VEC_TYPES = [
     "vec2",
     "vec3",
     "vec4",
-    "bvec2",
-    "bvec3",
-    "bvec4",
     "ivec2",
     "ivec3",
     "ivec4",
     "uvec2",
     "uvec3",
     "uvec4",
+];
+const PRELUDE = [
+    "float",
+    "int",
+    "uint",
+    ...VEC_TYPES,
+    "bvec2",
+    "bvec3",
+    "bvec4",
     "mat2",
     "mat3",
     "mat4",
@@ -58,8 +61,10 @@ const PRELUDE = [
 ]
     .map((x) => `const ${x} = env.${x};`)
     .join("\n");
+const POOL_PRELUDE = VEC_TYPES.map((x) => `const $${x} = env.pools.${x}.from;`).join("\n");
 const COMPS = { x: 0, y: 1, z: 2, w: 3 };
 const RE_SEMI = /[};]$/;
+const RESET = `for(let t in env.pools) env.pools[t].reset();`;
 const isIntOrBool = (l) => isInt(l) || isUint(l) || isBool(l);
 const isVecOrMat = (l) => isVec(l) || isMat(l);
 const swizzle = (id) => [...id].map((x) => COMPS[x]).join(", ");
@@ -79,6 +84,7 @@ export const targetJS = (opts) => {
         : String;
     const $list = (body, sep = ", ") => body.map(emit).join(sep);
     const $fn = (name, args) => `${name}(${$list(args)})`;
+    const $vecFromPool = ({ val, info, type }) => !info ? `$${type}(${$list(val)})` : `env.${type}${info}(${$list(val)})`;
     const $vec = ({ val, info, type }) => !info ? `[${$list(val)}]` : `env.${type}${info}(${$list(val)})`;
     const $num = (v, f) => isNumber(v) ? String(v) : f(v);
     const $float = (v, f) => (isNumber(v) ? ff(v) : f(v));
@@ -110,7 +116,19 @@ export const targetJS = (opts) => {
                     : undefined;
             return res.join(" ");
         },
-        fn: (t) => `${buildComments(t)}\nfunction ${t.id}(${$list(t.args)}) ${emit(t.scope)}`,
+        fn: (t) => {
+            let body;
+            if (t.id === "main") {
+                body = `{\n${RESET}\n${emit({
+                    ...t.scope,
+                    global: true,
+                })}}`;
+            }
+            else {
+                body = emit(t.scope);
+            }
+            return `${buildComments(t)}\nfunction ${t.id}(${$list(t.args)}) ${body}`;
+        },
         for: (t) => `for(${t.init ? emit(t.init) : ""}; ${emit(t.test)}; ${t.iter ? emit(t.iter) : ""}) ${emit(t.scope)}`,
         idx: (t) => `${emit(t.val)}[${emit(t.id)}]`,
         idxm: (t) => `${t.val.type}.idx(${emit(t.val)},${emit(t.id)})`,
@@ -132,15 +150,16 @@ export const targetJS = (opts) => {
                 case "vec2":
                 case "vec3":
                 case "vec4":
-                case "bvec2":
-                case "bvec3":
-                case "bvec4":
                 case "ivec2":
                 case "ivec3":
                 case "ivec4":
                 case "uvec2":
                 case "uvec3":
                 case "uvec4":
+                    return $vecFromPool(t);
+                case "bvec2":
+                case "bvec3":
+                case "bvec4":
                 case "mat2":
                 case "mat3":
                 case "mat4":
@@ -185,7 +204,7 @@ export const targetJS = (opts) => {
         scope: (t) => {
             let res = $list(t.body, ";\n");
             res += t.body.length && !RE_SEMI.test(res) ? ";" : "";
-            return !t.global ? `{\n${res}\n}` : res;
+            return t.global ? res : `{\n${res}\n}`;
         },
         swizzle: (t) => t.id.length > 1
             ? `env.swizzle${t.id.length}(${emit(t.val)}, ${swizzle(t.id)})`
@@ -197,7 +216,16 @@ export const targetJS = (opts) => {
     Object.assign(emit, {
         compile: (tree, env = JS_DEFAULT_ENV) => {
             const exports = buildExports(tree);
-            return new Function("env", [PRELUDE, emit(tree), "return {", exports, "};"].join("\n"))(env);
+            return new Function("env", [
+                PRELUDE,
+                POOL_PRELUDE,
+                emit(tree),
+                "return {",
+                `__reset: () => {${RESET}},`,
+                `__stats: () => Object.entries(env.pools).reduce((acc, [k, v]) => (acc[k] = v.index, acc), {}),`,
+                exports,
+                "};",
+            ].join("\n"))(env);
         },
     });
     return emit;