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

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-10-27T16:56:24Z
+- **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,12 @@ 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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/shader-ast-stdlib",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "Function collection for modular GPGPU / shader programming with @thi.ng/shader-ast",
   "type": "module",
   "module": "./index.js",
@@ -86,6 +86,7 @@
     "./*.d.ts",
     "color",
     "fog",
+    "isec",
     "light",
     "math",
     "matrix",
@@ -93,7 +94,8 @@
     "raymarch",
     "screen",
     "sdf",
-    "tex"
+    "tex",
+    "viz"
   ],
   "exports": {
     ".": {
@@ -352,5 +354,5 @@
     ],
     "year": 2019
   },
-  "gitHead": "502e8fa937677ff7bc4fbd0906d8c8b4b0b471e5\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)),
+]);