@thi.ng/shader-ast-stdlib 0.15.0 → 0.16.1

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-10-25T12:40:55Z
+- **Last updated**: 2023-10-27T20:44:01Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,18 @@ 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.16.1](https://github.com/thi-ng/umbrella/tree/@thi.ng/shader-ast-stdlib@0.16.1) (2023-10-27)
+
+#### 🩹 Bug fixes
+
+- fix pkg exports ([20d5d2d](https://github.com/thi-ng/umbrella/commit/20d5d2d))
+
+## [0.16.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/shader-ast-stdlib@0.16.0) (2023-10-27)
+
+#### 🚀 Features
+
+- add trunc(), modulo(), foldback01() ([d3ab3e6](https://github.com/thi-ng/umbrella/commit/d3ab3e6))
+
 ## [0.15.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/shader-ast-stdlib@0.15.0) (2023-10-25)
 
 #### 🚀 Features

package/README.md

@@ -105,7 +105,7 @@ For Node.js REPL:
 const shaderAstStdlib = await import("@thi.ng/shader-ast-stdlib");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 13.20 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 13.42 KB
 
 ## Dependencies
 

package/index.d.ts

@@ -18,6 +18,7 @@ export * from "./math/cross2.js";
 export * from "./math/dist-chebyshev.js";
 export * from "./math/dist-manhattan.js";
 export * from "./math/fit.js";
+export * from "./math/interval.js";
 export * from "./math/magsq.js";
 export * from "./math/maxcomp.js";
 export * from "./math/mincomp.js";

package/index.js

@@ -18,6 +18,7 @@ export * from "./math/cross2.js";
 export * from "./math/dist-chebyshev.js";
 export * from "./math/dist-manhattan.js";
 export * from "./math/fit.js";
+export * from "./math/interval.js";
 export * from "./math/magsq.js";
 export * from "./math/maxcomp.js";
 export * from "./math/mincomp.js";

package/isec/point.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Predicate function to check if given point `p` is inside the circle defined
+ * by `pos` and `radius`.
+ */
+export declare const isPointInCircle: import("@thi.ng/shader-ast").TaggedFn3<"vec2", "vec2", "float", "bool">;
+/**
+ * Predicate function to check if given point `p` is inside the axis-aligned
+ * rect defined by `pos` and `size`. Branchless.
+ */
+export declare const isPointInRect: import("@thi.ng/shader-ast").TaggedFn3<"vec2", "vec2", "vec2", "bool">;
+//# sourceMappingURL=point.d.ts.map

package/isec/point.js

@@ -0,0 +1,23 @@
+import { F, V2 } from "@thi.ng/shader-ast/api/types";
+import { defn, ret } from "@thi.ng/shader-ast/ast/function";
+import { bool } from "@thi.ng/shader-ast/ast/lit";
+import { add } 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 { distance, min, step } from "@thi.ng/shader-ast/builtin/math";
+/**
+ * Predicate function to check if given point `p` is inside the circle defined
+ * by `pos` and `radius`.
+ */
+export const isPointInCircle = defn("bool", null, [V2, V2, F], (p, pos, radius) => [ret(bool(step(distance(p, pos), radius)))]);
+/**
+ * Predicate function to check if given point `p` is inside the axis-aligned
+ * rect defined by `pos` and `size`. Branchless.
+ */
+export const isPointInRect = defn("bool", null, [V2, V2, V2], (p, pos, size) => {
+    let q;
+    return [
+        (q = sym(min(step(pos, p), step(p, add(pos, size))))),
+        ret(bool(min($x(q), $y(q)))),
+    ];
+});

package/math/fit.d.ts

@@ -8,6 +8,17 @@ import type { PrimTerm, Term, TermType } from "@thi.ng/shader-ast";
  * @param b -
  */
 export declare const fitNorm1: import("@thi.ng/shader-ast").TaggedFn3<"float", "float", "float", "float">;
+/**
+ * Similar to {@link fitNorm1} but also for vector types and without checking if
+ * `a == b`. Scales value `x` from closed interval [a,b] to closed [0,1]
+ * interval. No clamping performed.
+ *
+ * @param x
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare const fitNorm: <T extends PrimTerm>(x: T, a: T, b: T) => Term<TermType<T>>;
 /**
  * Fits value `x` from closed interval [a,b] to closed interval [c,d]. No
  * clamping performed.
@@ -19,16 +30,6 @@ export declare const fitNorm1: import("@thi.ng/shader-ast").TaggedFn3<"float", "
  * @param d -
  */
 export declare const fit: <T extends PrimTerm>(x: T, a: T, b: T, c: T, d: T) => Term<TermType<T>>;
-/**
- * Scales value `x` from closed interval [a,b] to closed [0,1] interval. No
- * clamping performed.
- *
- * @param x
- * @param a
- * @param b
- * @returns
- */
-export declare const fitNorm: <T extends PrimTerm>(x: T, a: T, b: T) => Term<TermType<T>>;
 /**
  * Same as {@link fit}, but first clamps `x` to closed [a,b] interval.
  *

package/math/fit.js

@@ -16,6 +16,17 @@ import { clamp01 } from "./clamp.js";
 export const fitNorm1 = defn(F, "fitNorm1", [F, F, F], (x, a, b) => [
     ret(ternary(neq(a, b), div(sub(x, a), sub(b, a)), FLOAT0)),
 ]);
+/**
+ * Similar to {@link fitNorm1} but also for vector types and without checking if
+ * `a == b`. Scales value `x` from closed interval [a,b] to closed [0,1]
+ * interval. No clamping performed.
+ *
+ * @param x
+ * @param a
+ * @param b
+ * @returns
+ */
+export const fitNorm = (x, a, b) => div(sub(x, a), sub(b, a));
 /**
  * Fits value `x` from closed interval [a,b] to closed interval [c,d]. No
  * clamping performed.
@@ -27,16 +38,6 @@ export const fitNorm1 = defn(F, "fitNorm1", [F, F, F], (x, a, b) => [
  * @param d -
  */
 export const fit = (x, a, b, c, d) => mix(c, d, fitNorm(x, a, b));
-/**
- * Scales value `x` from closed interval [a,b] to closed [0,1] interval. No
- * clamping performed.
- *
- * @param x
- * @param a
- * @param b
- * @returns
- */
-export const fitNorm = (x, a, b) => div(sub(x, a), sub(b, a));
 /**
  * Same as {@link fit}, but first clamps `x` to closed [a,b] interval.
  *

package/math/interval.d.ts

@@ -0,0 +1,17 @@
+/**
+ * GLSL 100 trunc() polyfill.
+ */
+export declare const trunc: import("@thi.ng/shader-ast").TaggedFn1<"float", "float">;
+/**
+ * Returns `x - y * trunc(x / y)`, i.e. essentially the same as JS `%` operator.
+ * Result will always have the sign of `x`.
+ */
+export declare const modulo: import("@thi.ng/shader-ast").TaggedFn2<"float", "float", "float">;
+/**
+ * Same as thi.ng/math foldback01(). Folds `x` into the closed [0..1] interval,
+ * using infinite internal reflection on either side of the interval.
+ *
+ * @param x
+ */
+export declare const foldback01: import("@thi.ng/shader-ast").TaggedFn1<"float", "float">;
+//# sourceMappingURL=interval.d.ts.map

package/math/interval.js

@@ -0,0 +1,33 @@
+import { F } from "@thi.ng/shader-ast/api/types";
+import { ternary } from "@thi.ng/shader-ast/ast/controlflow";
+import { defn, ret } from "@thi.ng/shader-ast/ast/function";
+import { FLOAT0, FLOAT1, FLOAT2 } from "@thi.ng/shader-ast/ast/lit";
+import { div, lt, mul, sub } from "@thi.ng/shader-ast/ast/ops";
+import { sym } from "@thi.ng/shader-ast/ast/sym";
+import { abs, ceil, floor, mix, mod, step, } from "@thi.ng/shader-ast/builtin/math";
+/**
+ * GLSL 100 trunc() polyfill.
+ */
+export const trunc = defn(F, null, [F], (x) => [
+    ret(ternary(lt(x, FLOAT0), ceil(x), floor(x))),
+]);
+/**
+ * Returns `x - y * trunc(x / y)`, i.e. essentially the same as JS `%` operator.
+ * Result will always have the sign of `x`.
+ */
+export const modulo = defn(F, null, [F, F], (x, y) => [
+    ret(sub(x, mul(y, trunc(div(x, y))))),
+]);
+/**
+ * Same as thi.ng/math foldback01(). Folds `x` into the closed [0..1] interval,
+ * using infinite internal reflection on either side of the interval.
+ *
+ * @param x
+ */
+export const foldback01 = defn(F, null, [F], (x) => {
+    let y;
+    return [
+        (y = sym(mod(abs(x), FLOAT2))),
+        ret(mix(y, sub(FLOAT2, y), step(FLOAT1, y))),
+    ];
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/shader-ast-stdlib",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "description": "Function collection for modular GPGPU / shader programming with @thi.ng/shader-ast",
   "type": "module",
   "module": "./index.js",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@thi.ng/api": "^8.9.6",
-    "@thi.ng/shader-ast": "^0.12.75"
+    "@thi.ng/shader-ast": "^0.12.76"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.0",
@@ -86,6 +86,7 @@
     "./*.d.ts",
     "color",
     "fog",
+    "isec",
     "light",
     "math",
     "matrix",
@@ -93,7 +94,8 @@
     "raymarch",
     "screen",
     "sdf",
-    "tex"
+    "tex",
+    "viz"
   ],
   "exports": {
     ".": {
@@ -162,6 +164,9 @@
     "./math/fit": {
       "default": "./math/fit.js"
     },
+    "./math/interval": {
+      "default": "./math/interval.js"
+    },
     "./math/magsq": {
       "default": "./math/magsq.js"
     },
@@ -349,5 +354,5 @@
     ],
     "year": 2019
   },
-  "gitHead": "fc6e14052ed24bf9196896980ceb9f398b6ea6c1\n"
+  "gitHead": "f540c4a501157b764229035035c2a858bace2a61\n"
 }

package/viz/function.d.ts

@@ -0,0 +1,68 @@
+import type { Func1, Func2, Vec2Term } from "@thi.ng/shader-ast";
+export interface FnSampleOpts {
+    /**
+     * Pixel radius per axis. The function will be sampled at ± N around the
+     * given base fragment position.
+     *
+     * @defaultValue 1
+     */
+    radius: number;
+    /**
+     * Number of sub-fragment steps per axis. The function will be sampled at ±
+     * {@link FnSampleOpts.radius} around the given base fragment position.
+     *
+     * @defaultValue 4
+     */
+    steps: number;
+    /**
+     * If true, the {@link functionSampler} will return 1.0 for the entire area
+     * below the curve (i.e. turns a line plot into an area plot). By default
+     * only the fragments touching the curve will produce non-zero results.
+     *
+     * @defaultValue false
+     */
+    area: boolean;
+    /**
+     * Min X position (in function domain). The function will only be evaluated
+     * within the [min..max] domain.
+     *
+     * @defaultValue 0
+     */
+    min: number;
+    /**
+     * Max X position (in function domain). The function will only be evaluated
+     * within the [min..max] domain.
+     *
+     * @defaultValue 1
+     */
+    max: number;
+}
+/**
+ * Higher order function. Takes a unary 1D function `fn` to evaluate and plot
+ * within a given interval. Also takes a point mapping function `map` to
+ * transform fragment coordinates into the function domain. Returns a new
+ * specialized function, which then accepts 2x vec2 args: a fragment coordinate
+ * and overall viewport dimensions. It then transforms the point into the
+ * function domain and evaluates/samples the function `fn` in the sub-pixel
+ * region around the input position. Returns a coverage ratio of how many
+ * samples where on the curve.
+ *
+ * @remarks
+ * The function domain, sampling region & quality can be configured via options.
+ * See {@link FnSampleOpts} for details.
+ *
+ * See {@link functionDomainMapper} for a configurable point mapping function.
+ */
+export declare const functionSampler: (fn: Func1<"float", "float">, map: Func2<"vec2", "vec2", "vec2">, opts?: Partial<FnSampleOpts>) => import("@thi.ng/shader-ast").TaggedFn2<"vec2", "vec2", "float">;
+/**
+ * Higher order helper function for {@link functionSampler} to map fragment
+ * coordinates within a screen rect (defined by `pos` & `size` in UV space) into
+ * the domain of the sampled function interval.
+ *
+ * @param amin
+ * @param amax
+ * @param bmin
+ * @param bmax
+ */
+export declare const functionDomainMapper: (amin: Vec2Term, amax: Vec2Term, bmin?: Vec2Term, bmax?: Vec2Term) => import("@thi.ng/shader-ast").TaggedFn2<"vec2", "vec2", "vec2">;
+//# sourceMappingURL=function.d.ts.map

package/viz/function.js

@@ -0,0 +1,77 @@
+import { F, V2 } from "@thi.ng/shader-ast/api/types";
+import { assign } from "@thi.ng/shader-ast/ast/assign";
+import { forLoop, ifThen } from "@thi.ng/shader-ast/ast/controlflow";
+import { defn, ret } from "@thi.ng/shader-ast/ast/function";
+import { FLOAT0, FLOAT2, VEC2_0, VEC2_1, float, vec2, } from "@thi.ng/shader-ast/ast/lit";
+import { add, div, gt, inc, lt, lte, or, 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 { fit } from "../math/fit.js";
+/**
+ * Higher order function. Takes a unary 1D function `fn` to evaluate and plot
+ * within a given interval. Also takes a point mapping function `map` to
+ * transform fragment coordinates into the function domain. Returns a new
+ * specialized function, which then accepts 2x vec2 args: a fragment coordinate
+ * and overall viewport dimensions. It then transforms the point into the
+ * function domain and evaluates/samples the function `fn` in the sub-pixel
+ * region around the input position. Returns a coverage ratio of how many
+ * samples where on the curve.
+ *
+ * @remarks
+ * The function domain, sampling region & quality can be configured via options.
+ * See {@link FnSampleOpts} for details.
+ *
+ * See {@link functionDomainMapper} for a configurable point mapping function.
+ */
+export const functionSampler = (fn, map, opts) => {
+    const { min, max, radius, step, area } = {
+        min: 0,
+        max: 1,
+        radius: 1,
+        step: 4,
+        area: false,
+        ...opts,
+    };
+    return defn(F, undefined, [V2, V2], (frag, res) => {
+        let count, total;
+        let q;
+        const invStep = float((2 * radius) / step);
+        return [
+            (q = sym(map(frag, res))),
+            // bail out early if outside [min..max] interval
+            ifThen(or(lt($x(q), float(min)), gt($x(q), float(max))), [
+                ret(FLOAT0),
+            ]),
+            (count = sym(FLOAT0)),
+            (total = sym(FLOAT0)),
+            forLoop(sym(float(-radius)), (x) => lte(x, float(radius)), (x) => assign(x, add(x, invStep)), (x) => [
+                forLoop(sym(float(-radius)), (y) => lte(y, float(radius)), (y) => assign(y, add(y, invStep)), (y) => [
+                    inc(total),
+                    assign(q, map(add(frag, vec2(x, y)), res)),
+                    ifThen(gt(fn($x(q)), $y(q)), [inc(count)]),
+                ]),
+            ]),
+            ...(!area
+                ? [
+                    ifThen(gt(count, div(total, FLOAT2)), [
+                        assign(count, sub(total, count)),
+                    ]),
+                ]
+                : []),
+            ret(div(count, total)),
+        ];
+    });
+};
+/**
+ * Higher order helper function for {@link functionSampler} to map fragment
+ * coordinates within a screen rect (defined by `pos` & `size` in UV space) into
+ * the domain of the sampled function interval.
+ *
+ * @param amin
+ * @param amax
+ * @param bmin
+ * @param bmax
+ */
+export const functionDomainMapper = (amin, amax, bmin = VEC2_0, bmax = VEC2_1) => defn(V2, undefined, [V2, V2], (p, res) => [
+    ret(fit(div(p, res), amin, amax, bmin, bmax)),
+]);