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

package/env/vec2.js

@@ -50,66 +50,67 @@ import { step2 } from "@thi.ng/vectors/step";
 import { sub2 } from "@thi.ng/vectors/sub";
 import { subN2 } from "@thi.ng/vectors/subn";
 import { tan2 } from "@thi.ng/vectors/tan";
-export const VEC2 = {
-    abs: (a) => abs2([], a),
-    acos: (a) => acos2([], a),
-    add: (a, b) => add2([], a, b),
-    addnv: (a, b) => addN2([], b, a),
-    addvn: (a, b) => addN2([], a, b),
-    asin: (a) => asin2([], a),
-    atan: (a) => atan2([], a),
-    atannn: (a, b) => atan_22([], a, b),
-    ceil: (a) => ceil2([], a),
-    clamp: (x, a, b) => clamp2([], x, a, b),
-    cos: (a) => cos2([], a),
-    dec: (a) => subN2([], a, 1),
-    degrees: (a) => degrees2([], a),
+import { Pool } from "../pool.js";
+export const VEC2 = ({ next, uniform }) => ({
+    abs: (a) => abs2(next(), a),
+    acos: (a) => acos2(next(), a),
+    add: (a, b) => add2(next(), a, b),
+    addnv: (a, b) => addN2(next(), b, a),
+    addvn: (a, b) => addN2(next(), a, b),
+    asin: (a) => asin2(next(), a),
+    atan: (a) => atan2(next(), a),
+    atannn: (a, b) => atan_22(next(), a, b),
+    ceil: (a) => ceil2(next(), a),
+    clamp: (x, a, b) => clamp2(next(), x, a, b),
+    cos: (a) => cos2(next(), a),
+    dec: (a) => subN2(next(), a, 1),
+    degrees: (a) => degrees2(next(), a),
     dFdx: () => ZERO2,
     dFdy: () => ZERO2,
     distance: dist,
-    div: (a, b) => div2([], a, b),
-    divnv: (a, b) => div2(null, [a, a], b),
-    divvn: (a, b) => divN2([], a, b),
+    div: (a, b) => div2(next(), a, b),
+    divnv: (a, b) => div2(null, uniform(a), b),
+    divvn: (a, b) => divN2(next(), a, b),
     dot: (a, b) => dot2(a, b),
-    exp: (a) => exp2([], a),
-    exp2: (a) => exp_22([], a),
-    faceForward: (a, b, c) => faceForward([], a, b, c),
-    floor: (a) => floor2([], a),
-    fract: (a) => fract2([], a),
+    exp: (a) => exp2(next(), a),
+    exp2: (a) => exp_22(next(), a),
+    faceForward: (a, b, c) => faceForward(next(), a, b, c),
+    floor: (a) => floor2(next(), a),
+    fract: (a) => fract2(next(), a),
     fwidth: () => ZERO2,
-    inc: (a) => addN2([], a, 1),
-    inversesqrt: (a) => invSqrt2([], a),
+    inc: (a) => addN2(next(), a, 1),
+    inversesqrt: (a) => invSqrt2(next(), a),
     length: mag,
-    log: (a) => log2([], a),
-    log2: (a) => log_22([], a),
-    max: (a, b) => max2([], a, b),
-    min: (a, b) => min2([], a, b),
-    mix: (a, b, t) => mix2([], a, b, t),
-    mixn: (a, b, t) => mixN2([], a, b, t),
-    mod: (a, b) => mod2([], a, b),
-    modn: (a, b) => modN2([], a, b),
-    mul: (a, b) => mul2([], a, b),
-    mulnv: (a, b) => mulN2([], b, a),
-    mulvn: (a, b) => mulN2([], a, b),
-    normalize: (a) => normalize2([], a),
-    pow: (a, b) => pow2([], a, b),
-    radians: (a) => radians2([], a),
-    reflect: (a, b) => reflect([], a, b),
-    refract: (a, b, c) => refract([], a, b, c),
-    sign: (a) => sign2([], a),
-    sin: (a) => sin2([], a),
-    smoothstep: (a, b, t) => smoothStep2([], a, b, t),
-    sqrt: (a) => sqrt2([], a),
-    step: (a, b) => step2([], a, b),
-    sub: (a, b) => sub2([], a, b),
-    sub1: (a) => neg([], a),
-    subnv: (a, b) => sub2(null, [a, a], b),
-    subvn: (a, b) => subN2([], a, b),
-    tan: (a) => tan2([], a),
+    log: (a) => log2(next(), a),
+    log2: (a) => log_22(next(), a),
+    max: (a, b) => max2(next(), a, b),
+    min: (a, b) => min2(next(), a, b),
+    mix: (a, b, t) => mix2(next(), a, b, t),
+    mixn: (a, b, t) => mixN2(next(), a, b, t),
+    mod: (a, b) => mod2(next(), a, b),
+    modn: (a, b) => modN2(next(), a, b),
+    mul: (a, b) => mul2(next(), a, b),
+    mulnv: (a, b) => mulN2(next(), b, a),
+    mulvn: (a, b) => mulN2(next(), a, b),
+    normalize: (a) => normalize2(next(), a),
+    pow: (a, b) => pow2(next(), a, b),
+    radians: (a) => radians2(next(), a),
+    reflect: (a, b) => reflect(next(), a, b),
+    refract: (a, b, c) => refract(next(), a, b, c),
+    sign: (a) => sign2(next(), a),
+    sin: (a) => sin2(next(), a),
+    smoothstep: (a, b, t) => smoothStep2(next(), a, b, t),
+    sqrt: (a) => sqrt2(next(), a),
+    step: (a, b) => step2(next(), a, b),
+    sub: (a, b) => sub2(next(), a, b),
+    sub1: (a) => neg(next(), a),
+    subnv: (a, b) => sub2(null, uniform(a), b),
+    subvn: (a, b) => subN2(next(), a, b),
+    tan: (a) => tan2(next(), a),
     equal: (a, b) => eq2([], a, b),
     notEqual: (a, b) => neq2([], a, b),
     greaterThan: (a, b) => gt2([], a, b),
     lessThan: (a, b) => lt2([], a, b),
     greaterThanEqual: (a, b) => gte2([], a, b),
     lessThanEqual: (a, b) => lte2([], a, b),
-};
+});

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.68",
+  "version": "1.0.1",
   "description": "Customizable JS codegen, compiler & runtime for @thi.ng/shader-ast",
   "type": "module",
   "module": "./index.js",
@@ -34,24 +34,28 @@
     "test": "testament test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.3",
-    "@thi.ng/checks": "^3.4.3",
-    "@thi.ng/errors": "^2.3.3",
-    "@thi.ng/math": "^5.5.4",
-    "@thi.ng/matrices": "^2.1.63",
-    "@thi.ng/pixel": "^4.2.13",
-    "@thi.ng/shader-ast": "^0.12.59",
-    "@thi.ng/vectors": "^7.7.6"
+    "@thi.ng/api": "^8.9.4",
+    "@thi.ng/checks": "^3.4.4",
+    "@thi.ng/errors": "^2.3.4",
+    "@thi.ng/math": "^5.5.5",
+    "@thi.ng/matrices": "^2.1.65",
+    "@thi.ng/pixel": "^4.2.15",
+    "@thi.ng/shader-ast": "^0.12.61",
+    "@thi.ng/vectors": "^7.7.8"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.36.4",
-    "@thi.ng/testament": "^0.3.21",
+    "@thi.ng/testament": "^0.3.22",
     "rimraf": "^5.0.1",
     "tools": "^0.0.1",
     "typedoc": "^0.24.8",
     "typescript": "^5.1.6"
   },
   "keywords": [
+    "2d",
+    "3d",
+    "4d",
+    "argb",
     "ast",
     "canvas",
     "codegen",
@@ -59,7 +63,14 @@
     "dsl",
     "emulator",
     "glsl",
+    "headless",
+    "pixel",
+    "render",
+    "rgb565",
+    "runtime",
     "shader",
+    "texture",
+    "transpiler",
     "typescript",
     "webgl"
   ],
@@ -132,6 +143,9 @@
     "./env": {
       "default": "./env.js"
     },
+    "./pool": {
+      "default": "./pool.js"
+    },
     "./runtime": {
       "default": "./runtime.js"
     },
@@ -142,10 +156,11 @@
   "thi.ng": {
     "parent": "@thi.ng/shader-ast",
     "related": [
+      "pixel",
       "shader-ast-glsl",
       "shader-ast-stdlib"
     ],
     "year": 2019
   },
-  "gitHead": "4154283d772824d4b57d4b7ab97be22a6e1ffdd7\n"
+  "gitHead": "74cfe3fb8de5bfcbfc1109e67604541cbd7b77aa\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