@thi.ng/shader-ast-js 0.7.67 → 1.0.0

package/env/vec3.d.ts

@@ -1,3 +1,4 @@
 import type { JSBuiltinsVec3 } from "../api.js";
-export declare const VEC3: JSBuiltinsVec3;
+import { Pool } from "../pool.js";
+export declare const VEC3: ({ next, uniform }: Pool) => JSBuiltinsVec3;
 //# sourceMappingURL=vec3.d.ts.map

package/env/vec3.js

@@ -51,67 +51,68 @@ import { step3 } from "@thi.ng/vectors/step";
 import { sub3 } from "@thi.ng/vectors/sub";
 import { subN3 } from "@thi.ng/vectors/subn";
 import { tan3 } from "@thi.ng/vectors/tan";
-export const VEC3 = {
-    abs: (a) => abs3([], a),
-    acos: (a) => acos3([], a),
-    add: (a, b) => add3([], a, b),
-    addnv: (a, b) => addN3([], b, a),
-    addvn: (a, b) => addN3([], a, b),
-    asin: (a) => asin3([], a),
-    atan: (a) => atan3([], a),
-    atannn: (a, b) => atan_23([], a, b),
-    ceil: (a) => ceil3([], a),
-    clamp: (x, a, b) => clamp3([], x, a, b),
-    cos: (a) => cos3([], a),
-    cross: (a, b) => cross3([], a, b),
-    dec: (a) => subN3([], a, 1),
-    degrees: (a) => degrees3([], a),
+import { Pool } from "../pool.js";
+export const VEC3 = ({ next, uniform }) => ({
+    abs: (a) => abs3(next(), a),
+    acos: (a) => acos3(next(), a),
+    add: (a, b) => add3(next(), a, b),
+    addnv: (a, b) => addN3(next(), b, a),
+    addvn: (a, b) => addN3(next(), a, b),
+    asin: (a) => asin3(next(), a),
+    atan: (a) => atan3(next(), a),
+    atannn: (a, b) => atan_23(next(), a, b),
+    ceil: (a) => ceil3(next(), a),
+    clamp: (x, a, b) => clamp3(next(), x, a, b),
+    cos: (a) => cos3(next(), a),
+    cross: (a, b) => cross3(next(), a, b),
+    dec: (a) => subN3(next(), a, 1),
+    degrees: (a) => degrees3(next(), a),
     dFdx: () => ZERO3,
     dFdy: () => ZERO3,
     distance: dist,
-    div: (a, b) => div3([], a, b),
-    divnv: (a, b) => div3(null, [a, a, a], b),
-    divvn: (a, b) => divN3([], a, b),
+    div: (a, b) => div3(next(), a, b),
+    divnv: (a, b) => div3(null, uniform(a), b),
+    divvn: (a, b) => divN3(next(), a, b),
     dot: (a, b) => dot3(a, b),
-    exp: (a) => exp3([], a),
-    exp2: (a) => exp_23([], a),
-    faceForward: (a, b, c) => faceForward([], a, b, c),
-    floor: (a) => floor3([], a),
-    fract: (a) => fract3([], a),
+    exp: (a) => exp3(next(), a),
+    exp2: (a) => exp_23(next(), a),
+    faceForward: (a, b, c) => faceForward(next(), a, b, c),
+    floor: (a) => floor3(next(), a),
+    fract: (a) => fract3(next(), a),
     fwidth: () => ZERO3,
-    inc: (a) => addN3([], a, 1),
-    inversesqrt: (a) => invSqrt3([], a),
+    inc: (a) => addN3(next(), a, 1),
+    inversesqrt: (a) => invSqrt3(next(), a),
     length: mag,
-    log: (a) => log3([], a),
-    log2: (a) => log_23([], a),
-    max: (a, b) => max3([], a, b),
-    min: (a, b) => min3([], a, b),
-    mix: (a, b, t) => mix3([], a, b, t),
-    mixn: (a, b, t) => mixN3([], a, b, t),
-    mod: (a, b) => mod3([], a, b),
-    modn: (a, b) => modN3([], a, b),
-    mul: (a, b) => mul3([], a, b),
-    mulnv: (a, b) => mulN3([], b, a),
-    mulvn: (a, b) => mulN3([], a, b),
-    normalize: (a) => normalize3([], a),
-    pow: (a, b) => pow3([], a, b),
-    radians: (a) => radians3([], a),
-    reflect: (a, b) => reflect([], a, b),
-    refract: (a, b, c) => refract([], a, b, c),
-    sign: (a) => sign3([], a),
-    sin: (a) => sin3([], a),
-    smoothstep: (a, b, t) => smoothStep3([], a, b, t),
-    sqrt: (a) => sqrt3([], a),
-    step: (a, b) => step3([], a, b),
-    sub: (a, b) => sub3([], a, b),
-    sub1: (a) => neg([], a),
-    subnv: (a, b) => sub3(null, [a, a, a], b),
-    subvn: (a, b) => subN3([], a, b),
-    tan: (a) => tan3([], a),
+    log: (a) => log3(next(), a),
+    log2: (a) => log_23(next(), a),
+    max: (a, b) => max3(next(), a, b),
+    min: (a, b) => min3(next(), a, b),
+    mix: (a, b, t) => mix3(next(), a, b, t),
+    mixn: (a, b, t) => mixN3(next(), a, b, t),
+    mod: (a, b) => mod3(next(), a, b),
+    modn: (a, b) => modN3(next(), a, b),
+    mul: (a, b) => mul3(next(), a, b),
+    mulnv: (a, b) => mulN3(next(), b, a),
+    mulvn: (a, b) => mulN3(next(), a, b),
+    normalize: (a) => normalize3(next(), a),
+    pow: (a, b) => pow3(next(), a, b),
+    radians: (a) => radians3(next(), a),
+    reflect: (a, b) => reflect(next(), a, b),
+    refract: (a, b, c) => refract(next(), a, b, c),
+    sign: (a) => sign3(next(), a),
+    sin: (a) => sin3(next(), a),
+    smoothstep: (a, b, t) => smoothStep3(next(), a, b, t),
+    sqrt: (a) => sqrt3(next(), a),
+    step: (a, b) => step3(next(), a, b),
+    sub: (a, b) => sub3(next(), a, b),
+    sub1: (a) => neg(next(), a),
+    subnv: (a, b) => sub3(null, uniform(a), b),
+    subvn: (a, b) => subN3(next(), a, b),
+    tan: (a) => tan3(next(), a),
     equal: (a, b) => eq3([], a, b),
     notEqual: (a, b) => neq3([], a, b),
     greaterThan: (a, b) => gt3([], a, b),
     lessThan: (a, b) => lt3([], a, b),
     greaterThanEqual: (a, b) => gte3([], a, b),
     lessThanEqual: (a, b) => lte3([], a, b),
-};
+});

package/env/vec4.d.ts

@@ -1,3 +1,4 @@
 import type { JSBuiltinsVec } from "../api.js";
-export declare const VEC4: JSBuiltinsVec;
+import { Pool } from "../pool.js";
+export declare const VEC4: ({ next, uniform }: Pool) => JSBuiltinsVec;
 //# sourceMappingURL=vec4.d.ts.map

package/env/vec4.js

@@ -50,66 +50,67 @@ import { step4 } from "@thi.ng/vectors/step";
 import { sub4 } from "@thi.ng/vectors/sub";
 import { subN4 } from "@thi.ng/vectors/subn";
 import { tan4 } from "@thi.ng/vectors/tan";
-export const VEC4 = {
-    abs: (a) => abs4([], a),
-    acos: (a) => acos4([], a),
-    add: (a, b) => add4([], a, b),
-    addnv: (a, b) => addN4([], b, a),
-    addvn: (a, b) => addN4([], a, b),
-    asin: (a) => asin4([], a),
-    atan: (a) => atan4([], a),
-    atannn: (a, b) => atan_24([], a, b),
-    ceil: (a) => ceil4([], a),
-    clamp: (x, a, b) => clamp4([], x, a, b),
-    cos: (a) => cos4([], a),
-    dec: (a) => subN4([], a, 1),
-    degrees: (a) => degrees4([], a),
+import { Pool } from "../pool.js";
+export const VEC4 = ({ next, uniform }) => ({
+    abs: (a) => abs4(next(), a),
+    acos: (a) => acos4(next(), a),
+    add: (a, b) => add4(next(), a, b),
+    addnv: (a, b) => addN4(next(), b, a),
+    addvn: (a, b) => addN4(next(), a, b),
+    asin: (a) => asin4(next(), a),
+    atan: (a) => atan4(next(), a),
+    atannn: (a, b) => atan_24(next(), a, b),
+    ceil: (a) => ceil4(next(), a),
+    clamp: (x, a, b) => clamp4(next(), x, a, b),
+    cos: (a) => cos4(next(), a),
+    dec: (a) => subN4(next(), a, 1),
+    degrees: (a) => degrees4(next(), a),
     dFdx: () => ZERO4,
     dFdy: () => ZERO4,
     distance: dist,
-    div: (a, b) => div4([], a, b),
-    divnv: (a, b) => div4(null, [a, a, a, a], b),
-    divvn: (a, b) => divN4([], a, b),
+    div: (a, b) => div4(next(), a, b),
+    divnv: (a, b) => div4(null, uniform(a), b),
+    divvn: (a, b) => divN4(next(), a, b),
     dot: (a, b) => dot4(a, b),
-    exp: (a) => exp4([], a),
-    exp2: (a) => exp_24([], a),
-    faceForward: (a, b, c) => faceForward([], a, b, c),
-    floor: (a) => floor4([], a),
-    fract: (a) => fract4([], a),
+    exp: (a) => exp4(next(), a),
+    exp2: (a) => exp_24(next(), a),
+    faceForward: (a, b, c) => faceForward(next(), a, b, c),
+    floor: (a) => floor4(next(), a),
+    fract: (a) => fract4(next(), a),
     fwidth: () => ZERO4,
-    inc: (a) => addN4([], a, 1),
-    inversesqrt: (a) => invSqrt4([], a),
+    inc: (a) => addN4(next(), a, 1),
+    inversesqrt: (a) => invSqrt4(next(), a),
     length: mag,
-    log: (a) => log4([], a),
-    log2: (a) => log_24([], a),
-    max: (a, b) => max4([], a, b),
-    min: (a, b) => min4([], a, b),
-    mix: (a, b, t) => mix4([], a, b, t),
-    mixn: (a, b, t) => mixN4([], a, b, t),
-    mod: (a, b) => mod4([], a, b),
-    modn: (a, b) => modN4([], a, b),
-    mul: (a, b) => mul4([], a, b),
-    mulnv: (a, b) => mulN4([], b, a),
-    mulvn: (a, b) => mulN4([], a, b),
-    normalize: (a) => normalize4([], a),
-    pow: (a, b) => pow4([], a, b),
-    radians: (a) => radians4([], a),
-    reflect: (a, b) => reflect([], a, b),
-    refract: (a, b, c) => refract([], a, b, c),
-    sign: (a) => sign4([], a),
-    sin: (a) => sin4([], a),
-    smoothstep: (a, b, t) => smoothStep4([], a, b, t),
-    sqrt: (a) => sqrt4([], a),
-    step: (a, b) => step4([], a, b),
-    sub: (a, b) => sub4([], a, b),
-    sub1: (a) => neg([], a),
-    subnv: (a, b) => sub4(null, [a, a, a, a], b),
-    subvn: (a, b) => subN4([], a, b),
-    tan: (a) => tan4([], a),
+    log: (a) => log4(next(), a),
+    log2: (a) => log_24(next(), a),
+    max: (a, b) => max4(next(), a, b),
+    min: (a, b) => min4(next(), a, b),
+    mix: (a, b, t) => mix4(next(), a, b, t),
+    mixn: (a, b, t) => mixN4(next(), a, b, t),
+    mod: (a, b) => mod4(next(), a, b),
+    modn: (a, b) => modN4(next(), a, b),
+    mul: (a, b) => mul4(next(), a, b),
+    mulnv: (a, b) => mulN4(next(), b, a),
+    mulvn: (a, b) => mulN4(next(), a, b),
+    normalize: (a) => normalize4(next(), a),
+    pow: (a, b) => pow4(next(), a, b),
+    radians: (a) => radians4(next(), a),
+    reflect: (a, b) => reflect(next(), a, b),
+    refract: (a, b, c) => refract(next(), a, b, c),
+    sign: (a) => sign4(next(), a),
+    sin: (a) => sin4(next(), a),
+    smoothstep: (a, b, t) => smoothStep4(next(), a, b, t),
+    sqrt: (a) => sqrt4(next(), a),
+    step: (a, b) => step4(next(), a, b),
+    sub: (a, b) => sub4(next(), a, b),
+    sub1: (a) => neg(next(), a),
+    subnv: (a, b) => sub4(null, uniform(a), b),
+    subvn: (a, b) => subN4(next(), a, b),
+    tan: (a) => tan4(next(), a),
     equal: (a, b) => eq4([], a, b),
     notEqual: (a, b) => neq4([], a, b),
     greaterThan: (a, b) => gt4([], a, b),
     lessThan: (a, b) => lt4([], a, b),
     greaterThanEqual: (a, b) => gte4([], a, b),
     lessThanEqual: (a, b) => lte4([], a, b),
-};
+});

package/env.js

@@ -22,6 +22,16 @@ import { UVEC4 } from "./env/uvec4.js";
 import { VEC2 } from "./env/vec2.js";
 import { VEC3 } from "./env/vec3.js";
 import { VEC4 } from "./env/vec4.js";
+import { POOL_IVEC2, POOL_IVEC3, POOL_IVEC4, POOL_UVEC2, POOL_UVEC3, POOL_UVEC4, POOL_VEC2, POOL_VEC3, POOL_VEC4, } from "./pool.js";
+const { next: $2, uniform: $n2 } = POOL_VEC2;
+const { next: $3, uniform: $n3 } = POOL_VEC3;
+const { next: $4, uniform: $n4 } = POOL_VEC4;
+const { next: $i2, uniform: $ni2 } = POOL_IVEC2;
+const { next: $i3, uniform: $ni3 } = POOL_IVEC3;
+const { next: $i4, uniform: $ni4 } = POOL_IVEC4;
+const { next: $u2, uniform: $nu2 } = POOL_UVEC2;
+const { next: $u3, uniform: $nu3 } = POOL_UVEC3;
+const { next: $u4, uniform: $nu4 } = POOL_UVEC4;
 // TODO texture lookups
 // all texture fns currently return [0,0,0,0] or 0
 const SAMPLER_TODO = {
@@ -40,34 +50,34 @@ const SAMPLER_TODO = {
     textureSize: () => ZERO3,
 };
 export const JS_DEFAULT_ENV = {
-    vec2: VEC2,
-    vec2b: (v) => fromBVec2([], v),
+    vec2: VEC2(POOL_VEC2),
+    vec2b: (v) => fromBVec2($2(), v),
     vec2i: identity,
-    vec2n: (n) => [n, n],
+    vec2n: $n2,
     vec2u: identity,
-    vec3: VEC3,
-    vec3b: (v) => fromBVec3([], v),
+    vec3: VEC3(POOL_VEC3),
+    vec3b: (v) => fromBVec3($3(), v),
     vec3i: identity,
-    vec3n: (n) => [n, n, n],
+    vec3n: $n3,
     vec3u: identity,
-    vec3vn: (a, n) => setVN3([], a, n),
-    vec4: VEC4,
-    vec4b: (v) => fromBVec4([], v),
+    vec3vn: (a, n) => setVN3($3(), a, n),
+    vec4: VEC4(POOL_VEC4),
+    vec4b: (v) => fromBVec4($4(), v),
     vec4i: identity,
-    vec4n: (n) => [n, n, n, n],
+    vec4n: $n4,
     vec4u: identity,
-    vec4vn: (a, n) => setVN4([], a, n),
-    vec4vnn: (a, z, w) => setVV4([], a, [z, w]),
-    vec4vv: (a, b) => setVV4([], a, b),
-    mat2n: (n) => mat22n([], n),
-    mat2vv: (a, b) => mat22v([], a, b),
+    vec4vn: (a, n) => setVN4($4(), a, n),
+    vec4vnn: (a, z, w) => setVV4($4(), a, [z, w]),
+    vec4vv: (a, b) => setVV4($4(), a, b),
+    mat2n: (n) => mat22n($4(), n),
+    mat2vv: (a, b) => mat22v($4(), a, b),
     mat3n: (n) => mat33n([], n),
     mat3vvv: (a, b, c) => mat33v([], a, b, c),
     mat4n: (n) => mat44n([], n),
     mat4vvvv: (a, b, c, d) => mat44v([], a, b, c, d),
-    swizzle2: (a, b, c) => swizzle2([], a, b, c),
-    swizzle3: (a, b, c, d) => swizzle3([], a, b, c, d),
-    swizzle4: (a, b, c, d, e) => swizzle4([], a, b, c, d, e),
+    swizzle2: (a, b, c) => swizzle2($2(), a, b, c),
+    swizzle3: (a, b, c, d) => swizzle3($3(), a, b, c, d),
+    swizzle4: (a, b, c, d, e) => swizzle4($4(), a, b, c, d, e),
     set_swizzle2: setSwizzle2,
     set_swizzle3: setSwizzle3,
     set_swizzle4: setSwizzle4,
@@ -81,23 +91,23 @@ export const JS_DEFAULT_ENV = {
     bvec4: BVEC4,
     bvec4n: (n) => ((n = !!n), [n, n, n, n]),
     ivec2: IVEC2,
-    ivec2b: (v) => fromBVec2([], v),
-    ivec2n: (n) => [n, n],
+    ivec2b: (v) => fromBVec2($i2(), v),
+    ivec2n: $ni2,
     ivec3: IVEC3,
-    ivec3b: (v) => fromBVec3([], v),
-    ivec3n: (n) => [n, n, n],
+    ivec3b: (v) => fromBVec3($i3(), v),
+    ivec3n: $ni3,
     ivec4: IVEC4,
-    ivec4b: (v) => fromBVec4([], v),
-    ivec4n: (n) => [n, n, n, n],
+    ivec4b: (v) => fromBVec4($i4(), v),
+    ivec4n: $ni4,
     uvec2: UVEC2,
-    uvec2b: (v) => fromBVec2([], v),
-    uvec2n: (n) => [n, n],
+    uvec2b: (v) => fromBVec2($u2(), v),
+    uvec2n: $nu2,
     uvec3: UVEC3,
-    uvec3b: (v) => fromBVec3([], v),
-    uvec3n: (n) => [n, n, n],
+    uvec3b: (v) => fromBVec3($u3(), v),
+    uvec3n: $nu3,
     uvec4: UVEC4,
-    uvec4b: (v) => fromBVec4([], v),
-    uvec4n: (n) => [n, n, n, n],
+    uvec4b: (v) => fromBVec4($u4(), v),
+    uvec4n: $nu4,
     mat2: MAT2,
     mat3: MAT3,
     mat4: MAT4,
@@ -107,4 +117,15 @@ export const JS_DEFAULT_ENV = {
     samplerCube: SAMPLER_TODO,
     sampler2DShadow: SAMPLER_TODO,
     samplerCubeShadow: SAMPLER_TODO,
+    pools: {
+        vec2: POOL_VEC2,
+        vec3: POOL_VEC3,
+        vec4: POOL_VEC4,
+        ivec2: POOL_IVEC2,
+        ivec3: POOL_IVEC3,
+        ivec4: POOL_IVEC4,
+        uvec2: POOL_UVEC2,
+        uvec3: POOL_UVEC3,
+        uvec4: POOL_UVEC4,
+    },
 };

package/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./api.js";
 export * from "./env.js";
+export * from "./pool.js";
 export * from "./runtime.js";
 export * from "./target.js";
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,4 +1,5 @@
 export * from "./api.js";
 export * from "./env.js";
+export * from "./pool.js";
 export * from "./runtime.js";
 export * from "./target.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/shader-ast-js",
-  "version": "0.7.67",
+  "version": "1.0.0",
   "description": "Customizable JS codegen, compiler & runtime for @thi.ng/shader-ast",
   "type": "module",
   "module": "./index.js",
@@ -38,10 +38,10 @@
     "@thi.ng/checks": "^3.4.3",
     "@thi.ng/errors": "^2.3.3",
     "@thi.ng/math": "^5.5.4",
-    "@thi.ng/matrices": "^2.1.62",
-    "@thi.ng/pixel": "^4.2.12",
-    "@thi.ng/shader-ast": "^0.12.58",
-    "@thi.ng/vectors": "^7.7.5"
+    "@thi.ng/matrices": "^2.1.64",
+    "@thi.ng/pixel": "^4.2.14",
+    "@thi.ng/shader-ast": "^0.12.60",
+    "@thi.ng/vectors": "^7.7.7"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.36.4",
@@ -132,6 +132,9 @@
     "./env": {
       "default": "./env.js"
     },
+    "./pool": {
+      "default": "./pool.js"
+    },
     "./runtime": {
       "default": "./runtime.js"
     },
@@ -147,5 +150,5 @@
     ],
     "year": 2019
   },
-  "gitHead": "399f8c53d66b9b763d16c21bb59f145df5f59514\n"
+  "gitHead": "4e8f1abeeba7b919e069954eada917ecd2e9a8e9\n"
 }

package/pool.d.ts

@@ -0,0 +1,37 @@
+import { type IReset, type Type, type TypedArray } from "@thi.ng/api";
+import type { Vec } from "@thi.ng/vectors";
+/**
+ * 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 declare class Pool implements IReset {
+    protected size: number;
+    protected cap: number;
+    mem: TypedArray;
+    items: Vec[];
+    index: number;
+    next: () => Vec;
+    from: (...args: number[]) => Vec;
+    uniform: (n: number) => Vec;
+    constructor(type: Type, size: number, cap: number);
+    reset(): this;
+}
+export declare const POOL_VEC2: Pool;
+export declare const POOL_VEC3: Pool;
+export declare const POOL_VEC4: Pool;
+export declare const POOL_IVEC2: Pool;
+export declare const POOL_IVEC3: Pool;
+export declare const POOL_IVEC4: Pool;
+export declare const POOL_UVEC2: Pool;
+export declare const POOL_UVEC3: Pool;
+export declare const POOL_UVEC4: Pool;
+//# sourceMappingURL=pool.d.ts.map

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: