@thi.ng/shader-ast-stdlib 0.16.31 → 0.18.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2024-03-01T15:22:50Z
+- **Last updated**: 2024-03-07T20:40:47Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,31 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+## [0.18.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/shader-ast-stdlib@0.18.0) (2024-03-07)
+
+#### 🚀 Features
+
+- add packFloat()/unpackFloat() ([23a6d7f](https://github.com/thi-ng/umbrella/commit/23a6d7f))
+- add packedNormal2(), refactor normal2() ([6f6dc1d](https://github.com/thi-ng/umbrella/commit/6f6dc1d))
+- add branches() n-ary helper fn & docs ([74f32ba](https://github.com/thi-ng/umbrella/commit/74f32ba))
+
+## [0.17.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/shader-ast-stdlib@0.17.0) (2024-03-06)
+
+#### 🚀 Features
+
+- add fbmNoiseVec34() ([40ea58d](https://github.com/thi-ng/umbrella/commit/40ea58d))
+- add cosineGradient() ([7a20ae9](https://github.com/thi-ng/umbrella/commit/7a20ae9))
+- update cossin(), sincos(), add opt. scale factor arg ([e3e8979](https://github.com/thi-ng/umbrella/commit/e3e8979))
+- add normal2() ([f6d6e33](https://github.com/thi-ng/umbrella/commit/f6d6e33))
+
+#### 🩹 Bug fixes
+
+- update generics for clamp01(), clamp11() and various fitXX() fns ([41d2882](https://github.com/thi-ng/umbrella/commit/41d2882))
+
+#### ♻️ Refactoring
+
+- simplify callsites of addSelf/mulSelf etc. ([efa1f8d](https://github.com/thi-ng/umbrella/commit/efa1f8d))
+
 ### [0.16.28](https://github.com/thi-ng/umbrella/tree/@thi.ng/shader-ast-stdlib@0.16.28) (2024-02-22)
 
 #### ♻️ Refactoring

package/README.md

@@ -51,7 +51,7 @@
 
 Function collection for modular GPGPU / shader programming with [@thi.ng/shader-ast](https://github.com/thi-ng/umbrella/tree/develop/packages/shader-ast).
 
-A growing collection (currently ~225) of useful functions & higher order
+A growing collection (currently ~230) of useful functions & higher order
 constructs (incl. meta programming approaches) for GPU / shader programming,
 acting as optional standard library for
 [@thi.ng/shader-ast](https://github.com/thi-ng/umbrella/tree/develop/packages/shader-ast)
@@ -109,7 +109,7 @@ For Node.js REPL:
 const shaderAstStdlib = await import("@thi.ng/shader-ast-stdlib");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 13.36 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 13.93 KB
 
 ## Dependencies
 
@@ -328,15 +328,20 @@ several other HOFs from this library to drastically simplify user code.
 
 ## API
 
-TODO. For now, please see doc strings in source for details...
+[Generated API docs](https://docs.thi.ng/umbrella/shader-ast-stdlib/)
 
 ### Color
 
 [/src/color](https://github.com/thi-ng/umbrella/tree/develop/packages/shader-ast-stdlib/src/color/)
 
+- `ACESFilm` (tone mapping)
+- `cosineGradient`
+- `levelAdjustGamma` / `levelAdjustGammaRGB`
+- `levelAdjustMid` / `levelAdjustMidRGB`
+- `luminanceRGB`
+- `midLevelGamma` / `midLevelGammaRGB`
 - `toLinear`
 - `toSRGB`
-- `luminanceRGB`
 - `decodeRGBE`
 
 ### Porter-Duff alpha blending
@@ -359,6 +364,10 @@ for reference.
 - `blendXor`
 - `blendPlus`
 
+Related:
+
+- `premultiplyAlpha` / `postmultiplyAlpha`
+
 ### Fog
 
 [/src/fog](https://github.com/thi-ng/umbrella/tree/develop/packages/shader-ast-stdlib/src/fog/)
@@ -399,6 +408,7 @@ for reference.
 - `minComp2` / `minComp3` / `minComp4`
 - `perpendicularCCW` / `perpendicularCW`
 - `orthogonal3`
+- `packFloat` / `unpackFloat`
 - `polar2` / `polar3`
 - `sincos` / `cossin`
 - `smootherStep` / `smootherStep2` / `smootherStep3` / `smootherStep4`
@@ -440,6 +450,7 @@ for reference.
 
 [/src/noise](https://github.com/thi-ng/umbrella/tree/develop/packages/shader-ast-stdlib/src/noise/)
 
+- `fbmNoiseVec34`
 - `hash2` / `hash3`
 - `hash11` / `hash12` / `hash13`
 - `hash21` / `hash22` / `hash23`
@@ -447,6 +458,7 @@ for reference.
 - `hash41` / `hash42` / `hash43` / `hash44`
 - `permute` / `permute3` / `permute4`
 - `snoise2`
+- `snoise3` / `snoiseVec32` / `snoiseVec3`
 - `voronoise2`
 - `worley2` / `worleyDist` / `worleyDistManhattan`
 
@@ -517,6 +529,7 @@ for reference.
 
 - `indexToCoord` / `coordToIndex`
 - `indexToUV` / `uvToIndex`
+- `normal2` / `packedNormal2`
 - `readIndex1` / `readIndex2` / `readIndex3` / `readIndex4`
 
 ### Visualization

package/color/cosine-gradient.d.ts

@@ -0,0 +1,28 @@
+import { type FloatTerm, type Vec3Term } from "@thi.ng/shader-ast";
+/**
+ * Inline function. Computes the unclamped cosine-based color gradient value:
+ * `a+b*cos(2π*(c*t+d))`, where `a`..`d` are the gradient coefficients and `t`
+ * the gradient position in the [0,1] interval.
+ *
+ * @remarks
+ * Based on technique by Inigo Quilez
+ *
+ * References:
+ * - https://iquilezles.org/articles/palettes/
+ * - https://github.com/thi-ng/umbrella/tree/develop/packages/color#cosine-gradients
+ *
+ * @example
+ * ```ts
+ * import { cosineGradient, COSINE_GRADIENTS } from "@thi.ng/shader-ast-stdlib";
+ *
+ * const rgb = cosineGradient(...COSINE_GRADIENTS["rainbow1"], 0.8)
+ * ```
+ *
+ * @param a
+ * @param b
+ * @param c
+ * @param d
+ * @param t
+ */
+export declare const cosineGradient: (a: Vec3Term, b: Vec3Term, c: Vec3Term, d: Vec3Term, t: FloatTerm) => import("@thi.ng/shader-ast").Op2<"vec3">;
+//# sourceMappingURL=cosine-gradient.d.ts.map

package/color/cosine-gradient.js

@@ -0,0 +1,10 @@
+import {
+  TAU,
+  add,
+  cos,
+  mul
+} from "@thi.ng/shader-ast";
+const cosineGradient = (a, b, c, d, t) => add(a, mul(b, cos(mul(TAU, add(mul(c, t), d)))));
+export {
+  cosineGradient
+};

package/color/levels.js

@@ -38,16 +38,7 @@ const levelAdjustGamma = defn(
   (x, gamma, input, output) => [
     ret(
       fit01(
-        pow(
-          fitClamped(
-            x,
-            $x(input),
-            $y(input),
-            FLOAT0,
-            FLOAT1
-          ),
-          gamma
-        ),
+        pow(fitClamped(x, $x(input), $y(input), FLOAT0, FLOAT1), gamma),
         $x(output),
         $y(output)
       )

package/controlflow/branches.d.ts

@@ -0,0 +1,53 @@
+import type { FloatTerm, Term, Type } from "@thi.ng/shader-ast";
+/**
+ * Utility function to create an n-ary conditional based on given float value
+ * `x` in [0,1] range and any number of branch terms (at least 1). Returns a
+ * nested ternary expression.
+ *
+ * @remarks
+ * This function is useful for A/B testing of multiple versions of a shader,
+ * e.g. the popular technique of using columns based on the `gl_FragCoord.x` and
+ * dynamically computed column thresholds (defined by the number of given branch
+ * terms).
+ *
+ * @example
+ * ```ts tangle:../../export/branches.ts
+ * import { float, sym, vec3 } from "@thi.ng/shader-ast";
+ * import { branches } from "@thi.ng/shader-ast-stdlib";
+ * import { targetGLSL } from "@thi.ng/shader-ast-glsl";
+ *
+ * // dummy "position" symbol (would be gl_FragCoord.x or similar)
+ * const pos = sym(float(0.11));
+ *
+ * // serialize expression to GLSL for better legibility
+ * console.log(
+ *   targetGLSL()(
+ *     branches(
+ *       pos,
+ *       // branch terms/options...
+ *       // branch thresholds are automatically computed
+ *       // making it trivial to add/remove terms
+ *       vec3(1,0,0),
+ *       vec3(1,1,0),
+ *       vec3(0,1,0),
+ *       vec3(0,0,1),
+ *     )
+ *   )
+ * );
+ *
+ * // re-formatted result:
+ * // ((_sf5 < 0.25)
+ * //   ? vec3(1.0, 0.0, 0.0)
+ * //   : ((_sf5 < 0.5)
+ * //   ? vec3(1.0, 1.0, 0.0)
+ * //   : ((_sf5 < 0.75)
+ * //   ? vec3(0.0, 1.0, 0.0)
+ * //   : vec3(0.0, 0.0, 1.0))))
+ * ```
+ *
+ * @param x
+ * @param a
+ * @param terms
+ */
+export declare const branches: <T extends Type>(x: FloatTerm, a: Term<T>, ...terms: Term<T>[]) => Term<T>;
+//# sourceMappingURL=branches.d.ts.map

package/controlflow/branches.js

@@ -0,0 +1,16 @@
+import { ternary } from "@thi.ng/shader-ast/ast/controlflow";
+import { float } from "@thi.ng/shader-ast/ast/lit";
+import { lt } from "@thi.ng/shader-ast/ast/ops";
+const branches = (x, a, ...terms) => {
+  const n = terms.length + 1;
+  if (n < 2)
+    return a;
+  const delta = 1 / n;
+  terms = [a, ...terms];
+  return terms.reduceRight(
+    (acc, t, i) => ternary(lt(x, float((i + 1) * delta)), t, acc)
+  );
+};
+export {
+  branches
+};

package/fog/exp2.js

@@ -1,12 +1,11 @@
 import { F } from "@thi.ng/shader-ast/api/types";
-import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { FLOAT1 } from "@thi.ng/shader-ast/ast/lit";
-import { mul, sub } from "@thi.ng/shader-ast/ast/ops";
+import { mul, mulSelf, sub } from "@thi.ng/shader-ast/ast/ops";
 import { exp2 } from "@thi.ng/shader-ast/builtin/math";
 import { clamp01 } from "../math/clamp.js";
 const fogExp2 = defn(F, "fogExp2", [F, F], (dist, density) => [
-  assign(density, mul(density, dist)),
+  mulSelf(density, dist),
   ret(sub(FLOAT1, clamp01(exp2(mul(mul(density, density), -Math.LOG2E)))))
 ]);
 export {

package/index.d.ts

@@ -1,10 +1,12 @@
 export * from "./api.js";
 export * from "./color/aces-film.js";
+export * from "./color/cosine-gradient.js";
 export * from "./color/levels.js";
 export * from "./color/linear-srgb.js";
 export * from "./color/luminance.js";
 export * from "./color/porter-duff.js";
 export * from "./color/rgbe.js";
+export * from "./controlflow/branches.js";
 export * from "./fog/exp.js";
 export * from "./fog/exp2.js";
 export * from "./fog/linear.js";
@@ -26,6 +28,7 @@ export * from "./math/mix-cubic.js";
 export * from "./math/mix-quadratic.js";
 export * from "./math/orthogonal.js";
 export * from "./math/osc.js";
+export * from "./math/pack-float.js";
 export * from "./math/polar.js";
 export * from "./math/sincos.js";
 export * from "./math/smoother-step.js";
@@ -35,6 +38,7 @@ export * from "./matrix/mvp.js";
 export * from "./matrix/normal.js";
 export * from "./matrix/rotation.js";
 export * from "./noise/curl3.js";
+export * from "./noise/fbm.js";
 export * from "./noise/hash.js";
 export * from "./noise/permute.js";
 export * from "./noise/simplex2.js";
@@ -76,6 +80,7 @@ export * from "./sdf/union.js";
 export * from "./tex/blur.js";
 export * from "./tex/index-coord.js";
 export * from "./tex/index-uv.js";
+export * from "./tex/normal.js";
 export * from "./tex/read-index.js";
 export * from "./viz/function.js";
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,10 +1,12 @@
 export * from "./api.js";
 export * from "./color/aces-film.js";
+export * from "./color/cosine-gradient.js";
 export * from "./color/levels.js";
 export * from "./color/linear-srgb.js";
 export * from "./color/luminance.js";
 export * from "./color/porter-duff.js";
 export * from "./color/rgbe.js";
+export * from "./controlflow/branches.js";
 export * from "./fog/exp.js";
 export * from "./fog/exp2.js";
 export * from "./fog/linear.js";
@@ -26,6 +28,7 @@ export * from "./math/mix-cubic.js";
 export * from "./math/mix-quadratic.js";
 export * from "./math/orthogonal.js";
 export * from "./math/osc.js";
+export * from "./math/pack-float.js";
 export * from "./math/polar.js";
 export * from "./math/sincos.js";
 export * from "./math/smoother-step.js";
@@ -35,6 +38,7 @@ export * from "./matrix/mvp.js";
 export * from "./matrix/normal.js";
 export * from "./matrix/rotation.js";
 export * from "./noise/curl3.js";
+export * from "./noise/fbm.js";
 export * from "./noise/hash.js";
 export * from "./noise/permute.js";
 export * from "./noise/simplex2.js";
@@ -76,5 +80,6 @@ export * from "./sdf/union.js";
 export * from "./tex/blur.js";
 export * from "./tex/index-coord.js";
 export * from "./tex/index-uv.js";
+export * from "./tex/normal.js";
 export * from "./tex/read-index.js";
 export * from "./viz/function.js";

package/math/additive.js

@@ -1,10 +1,16 @@
 import { F } from "@thi.ng/shader-ast/api/types";
-import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { forLoop } from "@thi.ng/shader-ast/ast/controlflow";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { gensym } from "@thi.ng/shader-ast/ast/idgen";
 import { FLOAT0, FLOAT05, float } from "@thi.ng/shader-ast/ast/lit";
-import { add, inc, lt, mul } from "@thi.ng/shader-ast/ast/ops";
+import {
+  add,
+  addSelf,
+  inc,
+  lt,
+  mul,
+  mulSelf
+} from "@thi.ng/shader-ast/ast/ops";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 const additive = (type, fn, oct = 4, name = gensym("additive_")) => defn(F, name, [[type], [type], F], (pos, shift, decay) => {
   let n;
@@ -17,15 +23,12 @@ const additive = (type, fn, oct = 4, name = gensym("additive_")) => defn(F, name
       (i) => lt(i, float(oct)),
       inc,
       (i) => [
-        assign(
+        addSelf(
           n,
-          add(
-            n,
-            mul(amp, fn(add(pos, mul(i, shift))))
-          )
+          mul(amp, fn(add(pos, mul(i, shift))))
         ),
-        assign(amp, mul(amp, decay)),
-        assign(pos, mul(pos, 2))
+        mulSelf(amp, decay),
+        mulSelf(pos, 2)
       ]
     ),
     ret(n)

package/math/cartesian.d.ts

@@ -5,7 +5,7 @@ import type { Vec2Term } from "@thi.ng/shader-ast";
  *
  * @param v -
  */
-export declare const cartesian2: (v: Vec2Term) => import("@thi.ng/shader-ast").Op2<"vec2">;
+export declare const cartesian2: (v: Vec2Term) => import("@thi.ng/shader-ast").Lit<"vec2"> | import("@thi.ng/shader-ast").Op2<"vec2">;
 /**
  * Converts 3D polar/spherical vector `v`, i.e. `[r,θ,ϕ]` (angles in
  * radians) to cartesian coordinates. See {@link polar3} for reverse

package/math/cartesian.js

@@ -5,7 +5,7 @@ import { mul } from "@thi.ng/shader-ast/ast/ops";
 import { $x, $y, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { cossin } from "./sincos.js";
-const cartesian2 = (v) => mul(cossin($y(v)), $x(v));
+const cartesian2 = (v) => cossin($y(v), $x(v));
 const cartesian3 = defn(V3, "cartesian3", [V3], (v) => {
   let r;
   let t;

package/math/clamp.d.ts

@@ -1,14 +1,14 @@
-import type { PrimTerm, Term, TermType } from "@thi.ng/shader-ast";
+import type { Prim, Term } from "@thi.ng/shader-ast";
 /**
  * Inline function, expands to equivalent of `clamp(x, 0, 1)`.
  *
  * @param x -
  */
-export declare const clamp01: <T extends PrimTerm>(x: T) => Term<TermType<T>>;
+export declare const clamp01: <T extends Prim>(x: Term<T>) => Term<T>;
 /**
  * Inline function, expands to equivalent of `clamp(x, -1, 1)`.
  *
  * @param x -
  */
-export declare const clamp11: <T extends PrimTerm>(x: T) => Term<TermType<T>>;
+export declare const clamp11: <T extends Prim>(x: Term<T>) => Term<T>;
 //# sourceMappingURL=clamp.d.ts.map

package/math/fit.d.ts

@@ -1,4 +1,4 @@
-import type { PrimTerm, Term, TermType } from "@thi.ng/shader-ast";
+import type { Prim, PrimTerm, Term, TermType } from "@thi.ng/shader-ast";
 /**
  * Returns normalized value of `x` WRT to interval [a,b]. Returns 0, if
  * `a` equals `b`.
@@ -16,9 +16,8 @@ export declare const fitNorm1: import("@thi.ng/shader-ast").TaggedFn3<"float", "
  * @param x
  * @param a
  * @param b
- * @returns
  */
-export declare const fitNorm: <T extends PrimTerm>(x: T, a: T, b: T) => Term<TermType<T>>;
+export declare const fitNorm: <T extends Prim>(x: Term<T>, a: Term<T>, b: Term<T>) => import("@thi.ng/shader-ast").Op2<T>;
 /**
  * Fits value `x` from closed interval [a,b] to closed interval [c,d]. No
  * clamping performed.
@@ -29,7 +28,7 @@ export declare const fitNorm: <T extends PrimTerm>(x: T, a: T, b: T) => Term<Ter
  * @param c -
  * @param d -
  */
-export declare const fit: <T extends PrimTerm>(x: T, a: T, b: T, c: T, d: T) => Term<TermType<T>>;
+export declare const fit: <T extends Prim>(x: Term<T>, a: Term<T>, b: Term<T>, c: Term<T>, d: Term<T>) => import("@thi.ng/shader-ast").FnCall<T>;
 /**
  * Same as {@link fit}, but first clamps `x` to closed [a,b] interval.
  *
@@ -39,7 +38,7 @@ export declare const fit: <T extends PrimTerm>(x: T, a: T, b: T, c: T, d: T) =>
  * @param c -
  * @param d -
  */
-export declare const fitClamped: <T extends PrimTerm>(x: T, a: T, b: T, c: T, d: T) => Term<TermType<T>>;
+export declare const fitClamped: <T extends Prim>(x: Term<T>, a: Term<T>, b: Term<T>, c: Term<T>, d: Term<T>) => import("@thi.ng/shader-ast").FnCall<T>;
 /**
  * Inline function. Fits value `a` in [0..1] interval to new interval
  * [b..c]. No clamping performed. Same as `mix(b, c, a)`
@@ -48,7 +47,7 @@ export declare const fitClamped: <T extends PrimTerm>(x: T, a: T, b: T, c: T, d:
  * @param b -
  * @param c -
  */
-export declare const fit01: <T extends PrimTerm>(a: T, b: T, c: T) => Term<TermType<T>>;
+export declare const fit01: <T extends Prim>(a: Term<T>, b: Term<T>, c: Term<T>) => Term<T>;
 /**
  * Inline function. Fits value `x` in [-1..+1] interval to [0..1]
  * interval. No clamping performed.

package/math/pack-float.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Encodes a float value in [0,1) interval to a vec4 suitable for a 8bit/channel
+ * render texture. Use {@link unpackFloat} for reverse op.
+ *
+ * @remarks
+ * Reference:
+ * https://aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/
+ */
+export declare const packFloat: import("@thi.ng/shader-ast").TaggedFn1<"float", "vec4">;
+/**
+ * Reverse op of {@link packFloat}.
+ *
+ * @remarks
+ * Also see {@link packedNormal2} for related functionality.
+ *
+ * Reference:
+ * https://aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/
+ */
+export declare const unpackFloat: import("@thi.ng/shader-ast").TaggedFn1<"vec4", "float">;
+//# sourceMappingURL=pack-float.d.ts.map

package/math/pack-float.js

@@ -0,0 +1,21 @@
+import { F, V4 } from "@thi.ng/shader-ast/api/types";
+import { defn, ret } from "@thi.ng/shader-ast/ast/function";
+import { vec4 } from "@thi.ng/shader-ast/ast/lit";
+import { mul, sub } from "@thi.ng/shader-ast/ast/ops";
+import { $ } from "@thi.ng/shader-ast/ast/swizzle";
+import { sym } from "@thi.ng/shader-ast/ast/sym";
+import { dot, fract } from "@thi.ng/shader-ast/builtin/math";
+const packFloat = defn(V4, null, [F], (x) => {
+  let res;
+  return [
+    res = sym(fract(mul(vec4(1, 255, 65025, 16581375), x))),
+    ret(sub(res, mul($(res, "yzww"), vec4(1 / 255, 1 / 255, 1 / 255, 0))))
+  ];
+});
+const unpackFloat = defn(F, null, [V4], (v) => [
+  ret(dot(v, vec4(1, 1 / 255, 1 / 65025, 1 / 16581375)))
+]);
+export {
+  packFloat,
+  unpackFloat
+};

package/math/sincos.d.ts

@@ -1,14 +1,16 @@
 import type { FloatTerm } from "@thi.ng/shader-ast";
 /**
- * Inline function. Returns vec2(sin(x), cos(x)).
+ * Inline function. Returns vec2(sin(x), cos(x)), optionally scaled by `r`
  *
  * @param x -
+ * @param r -
  */
-export declare const sincos: (x: FloatTerm) => import("@thi.ng/shader-ast").Lit<"vec2">;
+export declare const sincos: (x: FloatTerm, r?: FloatTerm | number) => import("@thi.ng/shader-ast").Lit<"vec2"> | import("@thi.ng/shader-ast").Op2<"vec2">;
 /**
- * Inline function. Returns vec2(cos(x), sin(x)).
+ * Inline function. Returns vec2(cos(x), sin(x)), optionally scaled by `r`.
  *
  * @param x -
+ * @param r -
  */
-export declare const cossin: (x: FloatTerm) => import("@thi.ng/shader-ast").Lit<"vec2">;
+export declare const cossin: (x: FloatTerm, r?: FloatTerm | number) => import("@thi.ng/shader-ast").Lit<"vec2"> | import("@thi.ng/shader-ast").Op2<"vec2">;
 //# sourceMappingURL=sincos.d.ts.map

package/math/sincos.js

@@ -1,7 +1,14 @@
 import { vec2 } from "@thi.ng/shader-ast/ast/lit";
+import { mul } from "@thi.ng/shader-ast/ast/ops";
 import { cos, sin } from "@thi.ng/shader-ast/builtin/math";
-const sincos = (x) => vec2(sin(x), cos(x));
-const cossin = (x) => vec2(cos(x), sin(x));
+const sincos = (x, r) => {
+  const res = vec2(sin(x), cos(x));
+  return r != void 0 ? mul(res, r) : res;
+};
+const cossin = (x, r) => {
+  const res = vec2(cos(x), sin(x));
+  return r != void 0 ? mul(res, r) : res;
+};
 export {
   cossin,
   sincos

package/noise/fbm.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Higher order function to compute 3D texture-based FBM noise for given number
+ * of octaves and decay factor (default: 1/octaves). Returns a 2-arg shader
+ * function, taking a sampler3D and vec3 position and which returns summed noise
+ * value as vec4.
+ *
+ * @remarks
+ * Not compatible with WebGL 1.0 (texture type not natively supported).
+ *
+ * The texture should be configured to use linear filtering and texture repeat
+ * mode.
+ *
+ * Using thi.ng/webgl (for example), the 3D noise texture can be initialized as
+ * follows:
+ *
+ * @example
+ * ```ts
+ * import { repeatedly } from "@thi.ng/transducers";
+ * import {
+ *   defTexture,
+ *   TextureFilter, TextureFormat, TextureRepeat, TextureTarget
+ * } from "@thi.ng/webgl";
+ *
+ * // (GL context creation omitted here)
+ *
+ * const noiseTex = defTexture(gl, {
+ *   width: 32,
+ *   height: 32,
+ *   depth: 32,
+ *   target: TextureTarget.TEXTURE_3D,
+ *   format: TextureFormat.RGB,
+ *   filter: TextureFilter.LINEAR,
+ *   wrap: TextureRepeat.REPEAT,
+ *   image: new Uint8Array(
+ *     repeatedly(() => Math.random() * 255.5, 32 * 32 * 32 * 3)
+ *   )
+ * });
+ * ```
+ *
+ * @param octaves
+ * @param decay
+ */
+export declare const fbmNoiseVec34: (octaves: number, decay?: number) => import("@thi.ng/shader-ast").TaggedFn2<"sampler3D", "vec3", "vec4">;
+//# sourceMappingURL=fbm.d.ts.map

package/noise/fbm.js

@@ -0,0 +1,35 @@
+import { S3D, V3, V4 } from "@thi.ng/shader-ast/api/types";
+import { forLoop } from "@thi.ng/shader-ast/ast/controlflow";
+import { defn, ret } from "@thi.ng/shader-ast/ast/function";
+import { FLOAT05, UINT0, uint, vec4 } from "@thi.ng/shader-ast/ast/lit";
+import {
+  addSelf,
+  div,
+  inc,
+  lt,
+  mul,
+  mulSelf
+} from "@thi.ng/shader-ast/ast/ops";
+import { sym } from "@thi.ng/shader-ast/ast/sym";
+import { texture } from "@thi.ng/shader-ast/builtin/texture";
+const fbmNoiseVec34 = (octaves, decay = 1 / octaves) => defn(V4, null, [S3D, V3], (tex, p) => {
+  let res;
+  let amp;
+  return [
+    res = sym(vec4()),
+    amp = sym(FLOAT05),
+    forLoop(
+      sym(UINT0),
+      (i) => lt(i, uint(octaves)),
+      inc,
+      () => [
+        addSelf(res, mul(texture(tex, div(p, amp)), amp)),
+        mulSelf(amp, decay)
+      ]
+    ),
+    ret(res)
+  ];
+});
+export {
+  fbmNoiseVec34
+};

package/noise/hash.js

@@ -1,8 +1,7 @@
 import { F, V2, V3, V4 } from "@thi.ng/shader-ast/api/types";
-import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { mat2, vec2, vec3, vec4 } from "@thi.ng/shader-ast/ast/lit";
-import { add, mul } from "@thi.ng/shader-ast/ast/ops";
+import { add, addSelf, mul, mulSelf } from "@thi.ng/shader-ast/ast/ops";
 import { $, $x, $y, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { dot, fract, sin } from "@thi.ng/shader-ast/builtin/math";
@@ -31,8 +30,8 @@ const hash11 = defn(F, "hash11", [F], (p) => {
   let x;
   return [
     x = sym(fract(mul(p, 0.1031))),
-    assign(x, mul(x, add(x, 19.19))),
-    assign(x, mul(x, add(x, x))),
+    mulSelf(x, add(x, 19.19)),
+    mulSelf(x, add(x, x)),
     ret(fract(x))
   ];
 });
@@ -40,7 +39,7 @@ const hash12 = defn(F, "hash12", [V2], (p) => {
   let x;
   return [
     x = sym(fract(mul($(p, "xyx"), 0.1031))),
-    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    addSelf(x, dot(x, add($(x, "yzx"), 19.19))),
     ret(fract(mul(add($x(x), $y(x)), $z(x))))
   ];
 });
@@ -48,7 +47,7 @@ const hash13 = defn(F, "hash13", [V3], (p) => {
   let x;
   return [
     x = sym(fract(mul($(p, "xyx"), 0.1031))),
-    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    addSelf(x, dot(x, add($(x, "yzx"), 19.19))),
     ret(fract(mul(add($x(x), $y(x)), $z(x))))
   ];
 });
@@ -56,7 +55,7 @@ const hash21 = defn(V2, "hash21", [F], (p) => {
   let x;
   return [
     x = sym(fract(mul(vec3(p), H))),
-    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    addSelf(x, dot(x, add($(x, "yzx"), 19.19))),
     ret(fract(mul(add($(x, "xx"), $(x, "yz")), $(x, "zy"))))
   ];
 });
@@ -64,7 +63,7 @@ const hash22 = defn(V2, "hash22", [V2], (p) => {
   let x;
   return [
     x = sym(fract(mul($(p, "xyx"), H))),
-    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    addSelf(x, dot(x, add($(x, "yzx"), 19.19))),
     ret(fract(mul(add($(x, "xx"), $(x, "yz")), $(x, "zy"))))
   ];
 });
@@ -72,7 +71,7 @@ const hash23 = defn(V2, "hash23", [V3], (p) => {
   let x;
   return [
     x = sym(fract(mul(p, H))),
-    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    addSelf(x, dot(x, add($(x, "yzx"), 19.19))),
     ret(fract(mul(add($(x, "xx"), $(x, "yz")), $(x, "zy"))))
   ];
 });
@@ -80,7 +79,7 @@ const hash31 = defn(V3, "hash31", [F], (p) => {
   let x;
   return [
     x = sym(fract(mul(p, H))),
-    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    addSelf(x, dot(x, add($(x, "yzx"), 19.19))),
     ret(fract(mul(add($(x, "xxy"), $(x, "yzz")), $(x, "zyx"))))
   ];
 });
@@ -88,7 +87,7 @@ const hash32 = defn(V3, "hash32", [V2], (p) => {
   let x;
   return [
     x = sym(fract(mul($(p, "xyx"), H))),
-    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    addSelf(x, dot(x, add($(x, "yzx"), 19.19))),
     ret(fract(mul(add($(x, "xxy"), $(x, "yzz")), $(x, "zyx"))))
   ];
 });
@@ -96,7 +95,7 @@ const hash33 = defn(V3, "hash33", [V3], (p) => {
   let x;
   return [
     x = sym(fract(mul(p, H))),
-    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    addSelf(x, dot(x, add($(x, "yzx"), 19.19))),
     ret(fract(mul(add($(x, "xxy"), $(x, "yzz")), $(x, "zyx"))))
   ];
 });
@@ -104,7 +103,7 @@ const hash41 = defn(V4, "hash41", [F], (p) => {
   let x;
   return [
     x = sym(fract(mul(p, H4))),
-    assign(x, add(x, dot(x, add($(x, "wzxy"), 19.19)))),
+    addSelf(x, dot(x, add($(x, "wzxy"), 19.19))),
     ret(fract(mul(add($(x, "xxyz"), $(x, "yzzw")), $(x, "zywx"))))
   ];
 });
@@ -112,7 +111,7 @@ const hash42 = defn(V4, "hash42", [V2], (p) => {
   let x;
   return [
     x = sym(fract(mul($(p, "xyxy"), H4))),
-    assign(x, add(x, dot(x, add($(x, "wzxy"), 19.19)))),
+    addSelf(x, dot(x, add($(x, "wzxy"), 19.19))),
     ret(fract(mul(add($(x, "xxyz"), $(x, "yzzw")), $(x, "zywx"))))
   ];
 });
@@ -120,7 +119,7 @@ const hash43 = defn(V4, "hash43", [V3], (p) => {
   let x;
   return [
     x = sym(fract(mul($(p, "xyzx"), H4))),
-    assign(x, add(x, dot(x, add($(x, "wzxy"), 19.19)))),
+    addSelf(x, dot(x, add($(x, "wzxy"), 19.19))),
     ret(fract(mul(add($(x, "xxyz"), $(x, "yzzw")), $(x, "zywx"))))
   ];
 });
@@ -128,7 +127,7 @@ const hash44 = defn(V4, "hash44", [V4], (p) => {
   let x;
   return [
     x = sym(fract(mul(p, H4))),
-    assign(x, add(x, dot(x, add($(x, "wzxy"), 19.19)))),
+    addSelf(x, dot(x, add($(x, "wzxy"), 19.19))),
     ret(fract(mul(add($(x, "xxyz"), $(x, "yzzw")), $(x, "zywx"))))
   ];
 });

package/noise/simplex2.js

@@ -11,7 +11,7 @@ import {
   vec3,
   vec4
 } from "@thi.ng/shader-ast/ast/lit";
-import { add, gt, mul, sub } from "@thi.ng/shader-ast/ast/ops";
+import { add, gt, mul, mulSelf, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $, $x, $xy, $y } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import {
@@ -68,20 +68,17 @@ const snoise2 = defn(F, "snoise2", [V2], (v) => {
         VEC3_0
       )
     ),
-    assign(m, mul(m, m)),
-    assign(m, mul(m, m)),
+    mulSelf(m, m),
+    mulSelf(m, m),
     x = sym(sub(mul(2, fract(mul(p, $(C, "www")))), FLOAT1)),
     h = sym(sub(abs(x), FLOAT05)),
     ox = sym(floor(add(x, FLOAT05))),
     a0 = sym(sub(x, ox)),
-    assign(
+    mulSelf(
       m,
-      mul(
-        m,
-        sub(
-          1.79284291400159,
-          mul(0.85373472095314, add(mul(a0, a0), mul(h, h)))
-        )
+      sub(
+        1.79284291400159,
+        mul(0.85373472095314, add(mul(a0, a0), mul(h, h)))
       )
     ),
     g = sym(vec3(add(mul($x(a0), $x(x0)), mul($x(h), $y(x0))))),

package/noise/simplex3.js

@@ -11,7 +11,7 @@ import {
   vec3,
   vec4
 } from "@thi.ng/shader-ast/ast/lit";
-import { add, mul, neg, sub } from "@thi.ng/shader-ast/ast/ops";
+import { add, mul, mulSelf, neg, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $, $w, $x, $xy, $y, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import {
@@ -119,10 +119,10 @@ const snoise3 = defn(F, "snoise3", [V3], (v) => {
         )
       )
     ),
-    assign(p0, mul(p0, $x(norm))),
-    assign(p1, mul(p1, $y(norm))),
-    assign(p2, mul(p2, $z(norm))),
-    assign(p3, mul(p3, $w(norm))),
+    mulSelf(p0, $x(norm)),
+    mulSelf(p1, $y(norm)),
+    mulSelf(p2, $z(norm)),
+    mulSelf(p3, $w(norm)),
     m = sym(
       max(
         vec4(),
@@ -132,7 +132,7 @@ const snoise3 = defn(F, "snoise3", [V3], (v) => {
         )
       )
     ),
-    assign(m, mul(m, m)),
+    mulSelf(m, m),
     ret(
       mul(
         42,

package/noise/voronoi2.js

@@ -1,5 +1,4 @@
 import { F, V2 } from "@thi.ng/shader-ast/api/types";
-import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { forLoop } from "@thi.ng/shader-ast/ast/controlflow";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import {
@@ -10,7 +9,15 @@ import {
   vec2,
   vec3
 } from "@thi.ng/shader-ast/ast/lit";
-import { add, div, inc, lte, madd, mul, sub } from "@thi.ng/shader-ast/ast/ops";
+import {
+  add,
+  addSelf,
+  div,
+  inc,
+  lte,
+  mul,
+  sub
+} from "@thi.ng/shader-ast/ast/ops";
 import { $xy, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import {
@@ -62,8 +69,8 @@ const voronoise2 = defn(F, "voronoise2", [V2, F, F], (x, u, v) => {
                 k
               )
             ),
-            assign(va, madd(w, $z(o), va)),
-            assign(wt, add(wt, w))
+            addSelf(va, mul(w, $z(o))),
+            addSelf(wt, w)
           ]
         )
       ]

package/noise/worley2.js

@@ -63,8 +63,8 @@ const worley2 = (distFn, name = gensym("worley2_")) => defn(V2, name, [V2, F], (
     d3 = sym($dist(-1.5)),
     d1a = sym(min(d1, d2)),
     assign(d2, min(max(d1, d2), d3)),
-    assign(d1, min(d1a, d2)),
-    assign(d2, max(d1a, d2)),
+    assign(d1, min(d2, d1a)),
+    assign(d2, max(d2, d1a)),
     assign($xy(d1), ternary(lt($x(d1), $y(d1)), $xy(d1), $(d1, "yx"))),
     assign(
       $(d1, "xz"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/shader-ast-stdlib",
-  "version": "0.16.31",
+  "version": "0.18.0",
   "description": "Function collection for modular GPGPU / shader programming with @thi.ng/shader-ast",
   "type": "module",
   "module": "./index.js",
@@ -35,11 +35,12 @@
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
     "doc:readme": "bun ../../tools/src/module-stats.ts && bun ../../tools/src/readme.ts",
     "pub": "yarn npm publish --access public",
-    "test": "bun test"
+    "test": "bun test",
+    "tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.27",
-    "@thi.ng/shader-ast": "^0.13.16"
+    "@thi.ng/api": "^8.9.28",
+    "@thi.ng/shader-ast": "^0.15.0"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.40.1",
@@ -85,6 +86,7 @@
     "./*.js",
     "./*.d.ts",
     "color",
+    "controlflow",
     "fog",
     "isec",
     "light",
@@ -107,6 +109,9 @@
     "./color/aces-film": {
       "default": "./color/aces-film.js"
     },
+    "./color/cosine-gradient": {
+      "default": "./color/cosine-gradient.js"
+    },
     "./color/levels": {
       "default": "./color/levels.js"
     },
@@ -122,6 +127,9 @@
     "./color/rgbe": {
       "default": "./color/rgbe.js"
     },
+    "./controlflow/branches": {
+      "default": "./controlflow/branches.js"
+    },
     "./fog/exp": {
       "default": "./fog/exp.js"
     },
@@ -188,6 +196,9 @@
     "./math/osc": {
       "default": "./math/osc.js"
     },
+    "./math/pack-float": {
+      "default": "./math/pack-float.js"
+    },
     "./math/polar": {
       "default": "./math/polar.js"
     },
@@ -215,6 +226,9 @@
     "./noise/curl3": {
       "default": "./noise/curl3.js"
     },
+    "./noise/fbm": {
+      "default": "./noise/fbm.js"
+    },
     "./noise/hash": {
       "default": "./noise/hash.js"
     },
@@ -338,6 +352,9 @@
     "./tex/index-uv": {
       "default": "./tex/index-uv.js"
     },
+    "./tex/normal": {
+      "default": "./tex/normal.js"
+    },
     "./tex/read-index": {
       "default": "./tex/read-index.js"
     },
@@ -354,5 +371,5 @@
     ],
     "year": 2019
   },
-  "gitHead": "df9e312af741d87e6b450afcfea6a6e381662b1e\n"
+  "gitHead": "a421058a65ba76608d94129ac29451bfedaf201c\n"
 }

package/raymarch/ao.js

@@ -1,10 +1,17 @@
 import { F, V3 } from "@thi.ng/shader-ast/api/types";
-import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { forLoop } from "@thi.ng/shader-ast/ast/controlflow";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { gensym } from "@thi.ng/shader-ast/ast/idgen";
 import { FLOAT0, FLOAT05, FLOAT1, float } from "@thi.ng/shader-ast/ast/lit";
-import { add, inc, lte, mul, sub } from "@thi.ng/shader-ast/ast/ops";
+import {
+  add,
+  addSelf,
+  inc,
+  lte,
+  mul,
+  mulSelf,
+  sub
+} from "@thi.ng/shader-ast/ast/ops";
 import { $x } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { clamp01 } from "../math/clamp.js";
@@ -21,11 +28,8 @@ const raymarchAO = (scene, numSamples = 5, name = gensym("raymarchAO_")) => defn
       inc,
       (i) => [
         d0 = sym(mul(i, 1 / numSamples)),
-        assign(
-          r,
-          add(r, mul(w, sub(d0, $x(scene(add(p, mul(n, d0)))))))
-        ),
-        assign(w, mul(w, FLOAT05))
+        addSelf(r, mul(w, sub(d0, $x(scene(add(p, mul(n, d0))))))),
+        mulSelf(w, FLOAT05)
       ]
     ),
     ret(sub(FLOAT1, clamp01(r)))

package/sdf/hex.js

@@ -1,8 +1,7 @@
 import { F, V2 } from "@thi.ng/shader-ast/api/types";
-import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { FLOAT0, vec2 } from "@thi.ng/shader-ast/ast/lit";
-import { mul, sub } from "@thi.ng/shader-ast/ast/ops";
+import { mul, subSelf } from "@thi.ng/shader-ast/ast/ops";
 import { $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import {
@@ -20,8 +19,8 @@ const sdfHexagon2 = defn(F, "sdfHexagon2", [V2, F], (p, r) => {
     // sin/cos @ 60deg
     k = sym(vec2(-0.8660254037844386, 0.5)),
     q = sym(abs(p)),
-    assign(q, sub(q, mul(k, mul(2, min(dot(k, q), FLOAT0))))),
-    assign(q, sub(q, vec2(clamp($x(q), mul(r, -TAN30), mul(r, TAN30)), r))),
+    subSelf(q, mul(k, mul(2, min(dot(k, q), FLOAT0)))),
+    subSelf(q, vec2(clamp($x(q), mul(r, -TAN30), mul(r, TAN30)), r)),
     ret(mul(length(q), sign($y(q))))
   ];
 });

package/sdf/polygon.js

@@ -19,7 +19,7 @@ import {
 import { $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { _any, all } from "@thi.ng/shader-ast/builtin/bvec";
-import { dot, min, sqrt } from "@thi.ng/shader-ast/builtin/math";
+import { dot, minSelf, sqrt } from "@thi.ng/shader-ast/builtin/math";
 import { clamp01 } from "../math/clamp.js";
 const sdfPolygon2 = (N) => defn(
   F,
@@ -48,7 +48,7 @@ const sdfPolygon2 = (N) => defn(
           b = sym(
             sub(w, mul(e, clamp01(div(dot(w, e), dot(e, e)))))
           ),
-          assign(d, min(d, dot(b, b))),
+          minSelf(d, dot(b, b)),
           c = sym(
             bvec3(
               gte($y(p), $y(pi)),

package/sdf/repeat-polar.js

@@ -14,7 +14,7 @@ const sdfRepeatPolar2 = defn(V2, "sdfRepeatPolar2", [V2, F], (p, n) => {
     angle = sym(div(TAU, n)),
     angle2 = sym(mul(angle, FLOAT05)),
     a = sym(sub(mod(add(angle2, atan($y(p), $x(p))), angle), angle2)),
-    ret(mul(cossin(a), length(p)))
+    ret(cossin(a, length(p)))
   ];
 });
 export {

package/tex/blur.js

@@ -1,16 +1,12 @@
 import { S2D, V2, V4 } from "@thi.ng/shader-ast/api/types";
-import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { vec2 } from "@thi.ng/shader-ast/ast/lit";
-import { add, div, mul, sub } from "@thi.ng/shader-ast/ast/ops";
+import { add, addSelf, div, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { texture } from "@thi.ng/shader-ast/builtin/texture";
-const singlePass = (col, tex, uv, off, k) => assign(
+const singlePass = (col, tex, uv, off, k) => addSelf(
   col,
-  add(
-    col,
-    mul(add(texture(tex, add(uv, off)), texture(tex, sub(uv, off))), k)
-  )
+  mul(add(texture(tex, add(uv, off)), texture(tex, sub(uv, off))), k)
 );
 const blur5 = defn(
   V4,

package/tex/normal.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Computes the surface normal from a grayscale texture at given `uv` position
+ * and using given `step` to define the half-distances between the 4 neighbor
+ * lookups (north/south/east/west). The `z` value is used as the normal's Z
+ * component (prior to normalization). `eps` is being added to all components to
+ * avoid zero-vectors.
+ *
+ * @remarks
+ * The function only uses the X (red) component of the texture.
+ *
+ * @param tex
+ * @param uv
+ * @param step
+ * @param z
+ * @param eps
+ */
+export declare const normal2: import("@thi.ng/shader-ast").TaggedFn5<"sampler2D", "vec2", "vec2", "float", "float", "vec3">;
+/**
+ * Principally the same as {@link normal2}, but using a RGBA 8bit/channel
+ * texture storing float values encoded using {@link packFloat}. WHen
+ * `packedNormal2()` then samples this textures, each value will be
+ * automatically decoded using {@link unpackFloat}.
+ *
+ * @param tex
+ * @param uv
+ * @param step
+ * @param z
+ * @param eps
+ */
+export declare const packedNormal2: import("@thi.ng/shader-ast").TaggedFn5<"sampler2D", "vec2", "vec2", "float", "float", "vec3">;
+//# sourceMappingURL=normal.d.ts.map

package/tex/normal.js

@@ -0,0 +1,35 @@
+import { F, S2D, V2, V3 } from "@thi.ng/shader-ast/api/types";
+import { defn, ret } from "@thi.ng/shader-ast/ast/function";
+import { vec2, vec3 } from "@thi.ng/shader-ast/ast/lit";
+import { add, sub } from "@thi.ng/shader-ast/ast/ops";
+import { $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
+import { sym } from "@thi.ng/shader-ast/ast/sym";
+import { normalize } from "@thi.ng/shader-ast/builtin/math";
+import { texture } from "@thi.ng/shader-ast/builtin/texture";
+import { unpackFloat } from "../math/pack-float.js";
+const __defNormal2 = (decode) => defn(V3, null, [S2D, V2, V2, F, F], (tex, uv, step, z, eps) => {
+  let sx;
+  let sy;
+  const sample1 = (tex2, uv2, unit) => sub(
+    decode(texture(tex2, sub(uv2, unit))),
+    decode(texture(tex2, add(uv2, unit)))
+  );
+  return [
+    sx = sym(vec2($x(step), 0)),
+    sy = sym(vec2(0, $y(step))),
+    ret(
+      normalize(
+        add(
+          vec3(sample1(tex, uv, sx), sample1(tex, uv, sy), z),
+          eps
+        )
+      )
+    )
+  ];
+});
+const normal2 = __defNormal2($x);
+const packedNormal2 = __defNormal2(unpackFloat);
+export {
+  normal2,
+  packedNormal2
+};

package/viz/function.js

@@ -12,6 +12,7 @@ import {
 } from "@thi.ng/shader-ast/ast/lit";
 import {
   add,
+  addSelf,
   div,
   gt,
   inc,
@@ -40,12 +41,12 @@ const functionSampler = (fn, map, opts = {}) => {
       forLoop(
         sym(float(-radius)),
         (x) => lte(x, float(radius)),
-        (x) => assign(x, add(x, invStep)),
+        (x) => addSelf(x, invStep),
         (x) => [
           forLoop(
             sym(float(-radius)),
             (y) => lte(y, float(radius)),
-            (y) => assign(y, add(y, invStep)),
+            (y) => addSelf(y, invStep),
             (y) => [
               inc(total),
               assign(q, map(add(frag, vec2(x, y)), res)),