glre 0.39.0 → 0.41.0

package/src/addons/math/cubic.ts

@@ -0,0 +1,101 @@
+import { Fn, Float, Vec2, Vec3, Vec4 } from '../../node'
+
+export const cubic = Fn(([v]: [Float]): Float => {
+        return v.mul(v).mul(v.mul(-2).add(3))
+}).setLayout({
+        name: 'cubicFloat',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'float' }],
+})
+
+export const cubicVec2 = Fn(([v]: [Vec2]): Vec2 => {
+        return v.mul(v).mul(v.mul(-2).add(3))
+}).setLayout({
+        name: 'cubicVec2',
+        type: 'vec2',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})
+
+export const cubicVec3 = Fn(([v]: [Vec3]): Vec3 => {
+        return v.mul(v).mul(v.mul(-2).add(3))
+}).setLayout({
+        name: 'cubicVec3',
+        type: 'vec3',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})
+
+export const cubicVec4 = Fn(([v]: [Vec4]): Vec4 => {
+        return v.mul(v).mul(v.mul(-2).add(3))
+}).setLayout({
+        name: 'cubicVec4',
+        type: 'vec4',
+        inputs: [{ name: 'v', type: 'vec4' }],
+})
+
+export const cubicFloatSlopes = Fn(([v, slope0, slope1]: [Float, Float, Float]): Float => {
+        const a = slope0.add(slope1).sub(2).toVar('a')
+        const b = slope0.mul(-2).sub(slope1).add(3).toVar('b')
+        const c = slope0.toVar('c')
+        const v2 = v.mul(v).toVar('v2')
+        const v3 = v.mul(v2).toVar('v3')
+        return a.mul(v3).add(b.mul(v2)).add(c.mul(v))
+}).setLayout({
+        name: 'cubicFloatSlopes',
+        type: 'float',
+        inputs: [
+                { name: 'v', type: 'float' },
+                { name: 'slope0', type: 'float' },
+                { name: 'slope1', type: 'float' },
+        ],
+})
+
+export const cubicVec2Slopes = Fn(([v, slope0, slope1]: [Vec2, Float, Float]): Vec2 => {
+        const a = slope0.add(slope1).sub(2).toVar('a')
+        const b = slope0.mul(-2).sub(slope1).add(3).toVar('b')
+        const c = slope0.toVar('c')
+        const v2 = v.mul(v).toVar('v2')
+        const v3 = v.mul(v2).toVar('v3')
+        return a.mul(v3).add(b.mul(v2)).add(c.mul(v))
+}).setLayout({
+        name: 'cubicVec2Slopes',
+        type: 'vec2',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 'slope0', type: 'float' },
+                { name: 'slope1', type: 'float' },
+        ],
+})
+
+export const cubicVec3Slopes = Fn(([v, slope0, slope1]: [Vec3, Float, Float]): Vec3 => {
+        const a = slope0.add(slope1).sub(2).toVar('a')
+        const b = slope0.mul(-2).sub(slope1).add(3).toVar('b')
+        const c = slope0.toVar('c')
+        const v2 = v.mul(v).toVar('v2')
+        const v3 = v.mul(v2).toVar('v3')
+        return a.mul(v3).add(b.mul(v2)).add(c.mul(v))
+}).setLayout({
+        name: 'cubicVec3Slopes',
+        type: 'vec3',
+        inputs: [
+                { name: 'v', type: 'vec3' },
+                { name: 'slope0', type: 'float' },
+                { name: 'slope1', type: 'float' },
+        ],
+})
+
+export const cubicVec4Slopes = Fn(([v, slope0, slope1]: [Vec4, Float, Float]): Vec4 => {
+        const a = slope0.add(slope1).sub(2).toVar('a')
+        const b = slope0.mul(-2).sub(slope1).add(3).toVar('b')
+        const c = slope0.toVar('c')
+        const v2 = v.mul(v).toVar('v2')
+        const v3 = v.mul(v2).toVar('v3')
+        return a.mul(v3).add(b.mul(v2)).add(c.mul(v))
+}).setLayout({
+        name: 'cubicVec4Slopes',
+        type: 'vec4',
+        inputs: [
+                { name: 'v', type: 'vec4' },
+                { name: 'slope0', type: 'float' },
+                { name: 'slope1', type: 'float' },
+        ],
+})

package/src/addons/math/cubicMix.ts

@@ -0,0 +1,49 @@
+import { X, Fn, Float, Vec2, Vec3, Vec4 } from '../../node'
+import { cubic, cubicVec2, cubicVec3, cubicVec4 } from './cubic'
+
+export const cubicMix = Fn(([a, b, t]: [Float, Float, Float]): X => {
+        return a.add(b.sub(a).mul(cubic(t)))
+}).setLayout({
+        name: 'cubicMix',
+        type: 'auto',
+        inputs: [
+                { name: 'a', type: 'auto' },
+                { name: 'b', type: 'auto' },
+                { name: 't', type: 'auto' },
+        ],
+})
+
+export const cubicMixVec2 = Fn(([a, b, t]: [Vec2, Vec2, Vec2]): X => {
+        return a.add(b.sub(a).mul(cubicVec2(t)))
+}).setLayout({
+        name: 'cubicMixVec2',
+        type: 'auto',
+        inputs: [
+                { name: 'a', type: 'auto' },
+                { name: 'b', type: 'auto' },
+                { name: 't', type: 'auto' },
+        ],
+})
+export const cubicMixVec3 = Fn(([a, b, t]: [Vec3, Vec3, Vec3]): X => {
+        return a.add(b.sub(a).mul(cubicVec3(t)))
+}).setLayout({
+        name: 'cubicMixVec3',
+        type: 'auto',
+        inputs: [
+                { name: 'a', type: 'auto' },
+                { name: 'b', type: 'auto' },
+                { name: 't', type: 'auto' },
+        ],
+})
+
+export const cubicMixVec4 = Fn(([a, b, t]: [Vec4, Vec4, Vec4]): X => {
+        return a.add(b.sub(a).mul(cubicVec4(t)))
+}).setLayout({
+        name: 'cubicMixVec4',
+        type: 'auto',
+        inputs: [
+                { name: 'a', type: 'auto' },
+                { name: 'b', type: 'auto' },
+                { name: 't', type: 'auto' },
+        ],
+})

package/src/addons/math/decimate.ts

@@ -0,0 +1,12 @@
+import { X, Fn } from '../../node'
+
+export const decimate = Fn(([v, p]: [X, X]): X => {
+        return v.mul(p).floor().div(p)
+}).setLayout({
+        name: 'decimate',
+        type: 'auto',
+        inputs: [
+                { name: 'v', type: 'auto' },
+                { name: 'p', type: 'auto' },
+        ],
+})

package/src/addons/math/dist.ts

@@ -0,0 +1,143 @@
+import { Fn, Vec2, Vec3, Vec4, Float, abs, distance, max, pow } from '../../node'
+
+const DIST_MINKOWSKI_P = 2.0
+
+export const distEuclidean = Fn(([a, b]: [Vec2 | Vec3 | Vec4, Vec2 | Vec3 | Vec4]): Float => {
+        return distance(a, b)
+}).setLayout({
+        name: 'distEuclidean',
+        type: 'float',
+        inputs: [
+                { name: 'a', type: 'auto' },
+                { name: 'b', type: 'auto' },
+        ],
+})
+
+export const distManhattan = Fn(([a, b]: [Vec2, Vec2]): Float => {
+        return abs(a.x.sub(b.x)).add(abs(a.y.sub(b.y)))
+}).setLayout({
+        name: 'distManhattan',
+        type: 'float',
+        inputs: [
+                { name: 'a', type: 'vec2' },
+                { name: 'b', type: 'vec2' },
+        ],
+})
+
+export const distManhattan3 = Fn(([a, b]: [Vec3, Vec3]): Float => {
+        return abs(a.x.sub(b.x))
+                .add(abs(a.y.sub(b.y)))
+                .add(abs(a.z.sub(b.z)))
+}).setLayout({
+        name: 'distManhattan',
+        type: 'float',
+        inputs: [
+                { name: 'a', type: 'vec3' },
+                { name: 'b', type: 'vec3' },
+        ],
+})
+
+export const distManhattan4 = Fn(([a, b]: [Vec4, Vec4]): Float => {
+        return abs(a.x.sub(b.x))
+                .add(abs(a.y.sub(b.y)))
+                .add(abs(a.z.sub(b.z)))
+                .add(abs(a.w.sub(b.w)))
+}).setLayout({
+        name: 'distManhattan',
+        type: 'float',
+        inputs: [
+                { name: 'a', type: 'vec4' },
+                { name: 'b', type: 'vec4' },
+        ],
+})
+
+export const distChebychev = Fn(([a, b]: [Vec2, Vec2]): Float => {
+        return max(abs(a.x.sub(b.x)), abs(a.y.sub(b.y)))
+}).setLayout({
+        name: 'distChebychev',
+        type: 'float',
+        inputs: [
+                { name: 'a', type: 'vec2' },
+                { name: 'b', type: 'vec2' },
+        ],
+})
+
+export const distChebychev3 = Fn(([a, b]: [Vec3, Vec3]): Float => {
+        return max(abs(a.x.sub(b.x)), max(abs(a.y.sub(b.y)), abs(a.z.sub(b.z))))
+}).setLayout({
+        name: 'distChebychev',
+        type: 'float',
+        inputs: [
+                { name: 'a', type: 'vec3' },
+                { name: 'b', type: 'vec3' },
+        ],
+})
+
+export const distChebychev4 = Fn(([a, b]: [Vec4, Vec4]): Float => {
+        return max(abs(a.x.sub(b.x)), max(abs(a.y.sub(b.y)), max(abs(a.z.sub(b.z)), abs(a.w.sub(b.w)))))
+}).setLayout({
+        name: 'distChebychev',
+        type: 'float',
+        inputs: [
+                { name: 'a', type: 'vec4' },
+                { name: 'b', type: 'vec4' },
+        ],
+})
+
+export const distMinkowski = Fn(([a, b]: [Vec2, Vec2]): Float => {
+        const p = DIST_MINKOWSKI_P
+        return pow(pow(abs(a.x.sub(b.x)), p).add(pow(abs(a.y.sub(b.y)), p)), 1 / p)
+}).setLayout({
+        name: 'distMinkowski',
+        type: 'float',
+        inputs: [
+                { name: 'a', type: 'vec2' },
+                { name: 'b', type: 'vec2' },
+        ],
+})
+
+export const distMinkowski3 = Fn(([a, b]: [Vec3, Vec3]): Float => {
+        const p = DIST_MINKOWSKI_P
+        return pow(
+                pow(abs(a.x.sub(b.x)), p)
+                        .add(pow(abs(a.y.sub(b.y)), p))
+                        .add(pow(abs(a.z.sub(b.z)), p)),
+                1 / p
+        )
+}).setLayout({
+        name: 'distMinkowski',
+        type: 'float',
+        inputs: [
+                { name: 'a', type: 'vec3' },
+                { name: 'b', type: 'vec3' },
+        ],
+})
+
+export const distMinkowski4 = Fn(([a, b]: [Vec4, Vec4]): Float => {
+        const p = DIST_MINKOWSKI_P
+        return pow(
+                pow(abs(a.x.sub(b.x)), p)
+                        .add(pow(abs(a.y.sub(b.y)), p))
+                        .add(pow(abs(a.z.sub(b.z)), p))
+                        .add(pow(abs(a.w.sub(b.w)), p)),
+                1 / p
+        )
+}).setLayout({
+        name: 'distMinkowski',
+        type: 'float',
+        inputs: [
+                { name: 'a', type: 'vec4' },
+                { name: 'b', type: 'vec4' },
+        ],
+})
+
+export const dist = Fn(([a, b]: [Vec2 | Vec3 | Vec4, Vec2 | Vec3 | Vec4]): Float => {
+        return distEuclidean(a, b)
+}).setLayout({
+        name: 'dist',
+        type: 'float',
+        inputs: [
+                { name: 'a', type: 'auto' },
+                { name: 'b', type: 'auto' },
+        ],
+})

package/src/addons/math/fcos.ts

@@ -0,0 +1,11 @@
+import { Fn, Float, cos, fwidth, smoothstep } from '../../node'
+import { TWO_PI } from './const'
+
+export const fcos = Fn(([x]: [Float]): Float => {
+        const w = fwidth(x)
+        return cos(x).mul(smoothstep(TWO_PI, 0, w))
+}).setLayout({
+        name: 'fcos',
+        type: 'float',
+        inputs: [{ name: 'x', type: 'float' }],
+})

package/src/addons/math/frac.ts

@@ -0,0 +1,9 @@
+import { Fn, X } from '../../node'
+
+export const frac = Fn(([x]: [X]): X => {
+        return x.fract()
+}).setLayout({
+        name: 'frac',
+        type: 'auto',
+        inputs: [{ name: 'x', type: 'auto' }],
+})

package/src/addons/math/gain.ts

@@ -0,0 +1,14 @@
+import { Fn, X, float, select } from '../../node'
+
+export const gain = Fn(([x, k]: [X, X]): X => {
+        const conditionValue = select(x.oneMinus(), x, x.lessThan(0.5))
+        const a = float(0.5).mul(float(2).mul(conditionValue).pow(k)).toVar('a')
+        return select(a.oneMinus(), a, x.lessThan(0.5))
+}).setLayout({
+        name: 'gain',
+        type: 'auto',
+        inputs: [
+                { name: 'x', type: 'auto' },
+                { name: 'k', type: 'auto' },
+        ],
+})

package/src/addons/math/gaussian.ts

@@ -0,0 +1,14 @@
+import { Fn, X, dot } from '../../node'
+
+export const gaussian = Fn(([d, s]: [X<'vec2' | 'vec3' | 'vec4' | 'ivec2' | 'ivec3' | 'ivec4'>, X]): X => {
+        const dotProduct = dot(d, d)
+        const variance = s.mul(s).mul(2)
+        return dotProduct.negate().div(variance).exp()
+}).setLayout({
+        name: 'gaussian',
+        type: 'float',
+        inputs: [
+                { name: 'd', type: 'auto' },
+                { name: 's', type: 'auto' },
+        ],
+})

package/src/addons/math/grad4.ts

@@ -0,0 +1,19 @@
+import { Fn, Float, Vec4, vec4, vec3, float } from '../../node'
+
+export const grad4 = Fn(([j, ip]: [Float, Vec4]): Vec4 => {
+        const ones = vec4(1, 1, 1, -1).toVar('ones')
+        const p = vec4(0).toVar('p')
+        const s = vec4(0).toVar('s')
+        p.xyz = vec3(j, j, j).mul(ip.xyz).fract().mul(7).floor().mul(ip.z).sub(1)
+        p.w = float(1.5).sub(p.xyz.abs().dot(ones.xyz))
+        s.assign(vec4(p.x.lessThan(0.0), p.y.lessThan(0.0), p.z.lessThan(0.0), p.w.lessThan(0.0)))
+        p.xyz = p.xyz.add(s.xyz.mul(2).sub(1).mul(s.www))
+        return p
+}).setLayout({
+        name: 'grad4',
+        type: 'vec4',
+        inputs: [
+                { name: 'j', type: 'float' },
+                { name: 'ip', type: 'vec4' },
+        ],
+})

package/src/addons/math/hammersley.ts

@@ -0,0 +1,54 @@
+import { PI } from './const'
+import { Fn, Int, Vec2, Vec3, float, vec2, vec3, uint } from '../../node'
+
+export const hammersley = Fn(([index, numSamples]: [Int, Int]): Vec2 => {
+        const tof = float(0.5).div(float(2147483648)).toVar('tof')
+        const bits = uint(index).toVar('bits')
+
+        bits.assign(bits.shiftLeft(uint(16)).bitOr(bits.shiftRight(uint(16))))
+        bits.assign(
+                bits
+                        .bitAnd(uint(0x55555555))
+                        .shiftLeft(uint(1))
+                        .bitOr(bits.bitAnd(uint(0xaaaaaaaa)).shiftRight(uint(1)))
+        )
+        bits.assign(
+                bits
+                        .bitAnd(uint(0x33333333))
+                        .shiftLeft(uint(2))
+                        .bitOr(bits.bitAnd(uint(0xcccccccc)).shiftRight(uint(2)))
+        )
+        bits.assign(
+                bits
+                        .bitAnd(uint(0x0f0f0f0f))
+                        .shiftLeft(uint(4))
+                        .bitOr(bits.bitAnd(uint(0xf0f0f0f0)).shiftRight(uint(4)))
+        )
+        bits.assign(
+                bits
+                        .bitAnd(uint(0x00ff00ff))
+                        .shiftLeft(uint(8))
+                        .bitOr(bits.bitAnd(uint(0xff00ff00)).shiftRight(uint(8)))
+        )
+
+        return vec2(float(index).div(float(numSamples)), float(bits).mul(tof))
+}).setLayout({
+        name: 'hammersley',
+        type: 'vec2',
+        inputs: [
+                { name: 'index', type: 'int' },
+                { name: 'numSamples', type: 'int' },
+        ],
+})
+
+export const hemisphereCosSample = Fn(([u]: [Vec2]): Vec3 => {
+        const phi = float(2).mul(PI).mul(u.x).toVar('phi')
+        const cosTheta2 = float(1).sub(u.y).toVar('cosTheta2')
+        const cosTheta = cosTheta2.sqrt().toVar('cosTheta')
+        const sinTheta = float(1).sub(cosTheta2).sqrt().toVar('sinTheta')
+        return vec3(phi.cos().mul(sinTheta), phi.sin().mul(sinTheta), cosTheta)
+}).setLayout({
+        name: 'hemisphereCosSample',
+        type: 'vec3',
+        inputs: [{ name: 'u', type: 'vec2' }],
+})

package/src/addons/math/highPass.ts

@@ -0,0 +1,12 @@
+import { Fn, Float, max, float } from '../../node'
+
+export const highPass = Fn(([v, b]: [Float, Float]): Float => {
+        return max(v.sub(b), 0).div(float(1).sub(b))
+}).setLayout({
+        name: 'highPass',
+        type: 'float',
+        inputs: [
+                { name: 'v', type: 'float' },
+                { name: 'b', type: 'float' },
+        ],
+})

package/src/addons/math/index.ts

@@ -0,0 +1,63 @@
+export * from './aafloor'
+export * from './aafract'
+export * from './aamirror'
+export * from './aastep'
+export * from './absi'
+export * from './adaptiveThreshold'
+export * from './bump'
+export * from './const'
+export * from './cubic'
+export * from './cubicMix'
+export * from './decimate'
+export * from './dist'
+export * from './fcos'
+export * from './frac'
+export * from './gain'
+export * from './gaussian'
+export * from './grad4'
+export * from './hammersley'
+export * from './highPass'
+export * from './inside'
+export * from './invCubic'
+export * from './invQuartic'
+export * from './inverse'
+export * from './lengthSq'
+export * from './map'
+export * from './mirror'
+export * from './mmax'
+export * from './mmin'
+export * from './mmix'
+export * from './mod289'
+export * from './mod2'
+export * from './modi'
+export * from './nyquist'
+export * from './pack'
+export * from './parabola'
+export * from './permute'
+export * from './pow2'
+export * from './pow3'
+export * from './pow5'
+export * from './pow7'
+export * from './powFast'
+export * from './quat'
+export * from './quartic'
+export * from './quintic'
+export * from './rotate2d'
+export * from './rotate3d'
+export * from './rotate3dX'
+export * from './rotate3dY'
+export * from './rotate3dZ'
+export * from './rotate4d'
+export * from './rotate4dX'
+export * from './rotate4dY'
+export * from './rotate4dZ'
+export * from './saturateMediump'
+export * from './scale2d'
+export * from './scale3d'
+export * from './scale4d'
+export * from './smootherstep'
+export * from './taylorInvSqrt'
+export * from './toMat3'
+export * from './toMat4'
+export * from './translate4d'
+export * from './unpack'

package/src/addons/math/inside.ts

@@ -0,0 +1,68 @@
+import { Fn, all } from '../../node'
+import type { Bool, Float, Vec2, Vec3, Vec4, X } from '../../node/types'
+
+export const inside = Fn(([x, min, max]: [X, X, X]): Bool => {
+        return all(x.greaterThanEqual(min).and(x.lessThanEqual(max)))
+}).setLayout({
+        name: 'inside',
+        type: 'bool',
+        inputs: [
+                { name: 'x', type: 'auto' },
+                { name: 'min', type: 'auto' },
+                { name: 'max', type: 'auto' },
+        ],
+})
+
+export const insideFloat = Fn(([x, min, max]: [Float, Float, Float]): Bool => {
+        return x.greaterThanEqual(min).and(x.lessThanEqual(max))
+}).setLayout({
+        name: 'insideFloat',
+        type: 'bool',
+        inputs: [
+                { name: 'x', type: 'float' },
+                { name: 'min', type: 'float' },
+                { name: 'max', type: 'float' },
+        ],
+})
+
+export const insideVec2 = Fn(([v, min, max]: [Vec2, Vec2, Vec2]): Bool => {
+        return v.x
+                .greaterThanEqual(min.x)
+                .and(v.x.lessThanEqual(max.x))
+                .and(v.y.greaterThanEqual(min.y).and(v.y.lessThanEqual(max.y)))
+}).setLayout({
+        name: 'insideVec2',
+        type: 'bool',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 'min', type: 'vec2' },
+                { name: 'max', type: 'vec2' },
+        ],
+})
+
+export const insideVec3 = Fn(([v, min, max]: [Vec3, Vec3, Vec3]): Bool => {
+        return v.x
+                .greaterThanEqual(min.x)
+                .and(v.x.lessThanEqual(max.x))
+                .and(v.y.greaterThanEqual(min.y).and(v.y.lessThanEqual(max.y)))
+                .and(v.z.greaterThanEqual(min.z).and(v.z.lessThanEqual(max.z)))
+}).setLayout({
+        name: 'insideVec3',
+        type: 'bool',
+        inputs: [
+                { name: 'v', type: 'vec3' },
+                { name: 'min', type: 'vec3' },
+                { name: 'max', type: 'vec3' },
+        ],
+})
+
+export const insideAABB = Fn(([v, aabb]: [Vec2, Vec4]): Bool => {
+        return insideVec2(v, aabb.xy, aabb.zw)
+}).setLayout({
+        name: 'insideAABB',
+        type: 'bool',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 'aabb', type: 'vec4' },
+        ],
+})

package/src/addons/math/invCubic.ts

@@ -0,0 +1,9 @@
+import { Fn, X, float } from '../../node'
+
+export const invCubic = Fn(([v]: [X]): X => {
+        return float(0.5).sub(float(1).sub(float(2).mul(v)).asin().div(3).sin())
+}).setLayout({
+        name: 'invCubic',
+        type: 'auto',
+        inputs: [{ name: 'v', type: 'auto' }],
+})

package/src/addons/math/invQuartic.ts

@@ -0,0 +1,9 @@
+import { Fn, X } from '../../node'
+
+export const invQuartic = Fn(([v]: [X]): X => {
+        return v.oneMinus().sqrt().oneMinus().sqrt()
+}).setLayout({
+        name: 'invQuartic',
+        type: 'auto',
+        inputs: [{ name: 'v', type: 'auto' }],
+})

package/src/addons/math/inverse.ts

@@ -0,0 +1,9 @@
+import { Fn, X, float } from '../../node'
+
+export const inverse = Fn(([m]: [X]): X => {
+        return float(1).div(m)
+}).setLayout({
+        name: 'reciprocal',
+        type: 'auto',
+        inputs: [{ name: 'm', type: 'auto' }],
+})

package/src/addons/math/lengthSq.ts

@@ -0,0 +1,10 @@
+import { Fn } from '../../node'
+import type { Vec2, X } from '../../node/types'
+
+export const lengthSq = Fn(([v]: [X]): X => {
+        return (v as Vec2).dot(v as Vec2) as X
+}).setLayout({
+        name: 'lengthSq',
+        type: 'auto',
+        inputs: [{ name: 'v', type: 'auto' }],
+})

package/src/addons/math/map.ts

@@ -0,0 +1,27 @@
+import { Fn, X } from '../../node'
+
+export const map = Fn(([v, iMin, iMax]: [X, X, X]): X => {
+        return v.sub(iMin).div(iMax.sub(iMin))
+}).setLayout({
+        name: 'map',
+        type: 'auto',
+        inputs: [
+                { name: 'v', type: 'auto' },
+                { name: 'iMin', type: 'auto' },
+                { name: 'iMax', type: 'auto' },
+        ],
+})
+
+export const mapRange = Fn(([v, iMin, iMax, oMin, oMax]: [X, X, X, X, X]): X => {
+        return oMin.add(oMax.sub(oMin).mul(v.sub(iMin).div(iMax.sub(iMin))))
+}).setLayout({
+        name: 'mapRange',
+        type: 'auto',
+        inputs: [
+                { name: 'v', type: 'auto' },
+                { name: 'iMin', type: 'auto' },
+                { name: 'iMax', type: 'auto' },
+                { name: 'oMin', type: 'auto' },
+                { name: 'oMax', type: 'auto' },
+        ],
+})

package/src/addons/math/mirror.ts

@@ -0,0 +1,12 @@
+import { Fn, X } from '../../node'
+
+export const mirror = Fn(([x]: [X]): X => {
+        const f = x.fract()
+        const m = x.mod(2).floor()
+        const fm = f.mul(m)
+        return f.add(m).sub(fm.mul(2))
+}).setLayout({
+        name: 'mirror',
+        type: 'auto',
+        inputs: [{ name: 'x', type: 'auto' }],
+})