glre 0.38.0 → 0.40.0

package/src/addons/generative/snoise.ts

@@ -0,0 +1,199 @@
+import { Fn, Float, Vec2, Vec3, Vec4, vec2, vec3, vec4, float } from '../../node'
+import { mod289Vec2, mod289Vec3, mod289Vec4 } from '../math/mod289'
+import { permute, permuteVec3, permuteVec4 } from '../math/permute'
+import { taylorInvSqrt } from '../math/taylorInvSqrt'
+import { grad4 } from '../math/grad4'
+
+export const snoiseVec2 = Fn(([v]: [Vec2]): Float => {
+        const C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439).toVar('C')
+        const i = v.add(v.dot(C.yy)).floor().toVar('i')
+        const x0 = v.sub(i).add(i.dot(C.xx)).toVar('x0')
+        const i1 = vec2(1, 0).select(vec2(0, 1), x0.x.greaterThan(x0.y)).toVar('i1')
+        const x12 = x0.xyxy.add(C.xxzz).toVar('x12')
+        x12.xy = x12.xy.sub(i1)
+        i.assign(mod289Vec2(i))
+        const p = permuteVec3(
+                permuteVec3(i.y.add(vec3(0, i1.y, 1)))
+                        .add(i.x)
+                        .add(vec3(0, i1.x, 1))
+        ).toVar('p')
+        const m = float(0.5)
+                .sub(vec3(x0.dot(x0), x12.xy.dot(x12.xy), x12.zw.dot(x12.zw)))
+                .max(0)
+                .toVar('m')
+        m.assign(m.mul(m))
+        m.assign(m.mul(m))
+        const x = p.mul(C.www).fract().mul(2).sub(1).toVar('x')
+        const h = x.abs().sub(0.5).toVar('h')
+        const ox = x.add(0.5).floor().toVar('ox')
+        const a0 = x.sub(ox).toVar('a0')
+        m.mulAssign(float(1.79284291400159).sub(float(0.85373472095314).mul(a0.mul(a0).add(h.mul(h)))))
+        const g = vec3(a0.x.mul(x0.x).add(h.x.mul(x0.y)), a0.yz.mul(x12.xz).add(h.yz.mul(x12.yw))).toVar('g')
+        return float(130).mul(m.dot(g))
+}).setLayout({
+        name: 'snoiseVec2',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})
+
+export const snoiseVec3 = Fn(([v]: [Vec3]): Float => {
+        const C = vec2(1 / 6, 1 / 3).toVar('C')
+        const D = vec4(0, 0.5, 1, 2).toVar('D')
+        const i = v.add(v.dot(C.yyy)).floor().toVar('i')
+        const x0 = v.sub(i).add(i.dot(C.xxx)).toVar('x0')
+        const g = x0.yzx.step(x0.xyz).toVar('g')
+        const l = float(1).sub(g).toVar('l')
+        const i1 = g.xyz.min(l.zxy).toVar('i1')
+        const i2 = g.xyz.max(l.zxy).toVar('i2')
+        const x1 = x0.sub(i1).add(C.xxx).toVar('x1')
+        const x2 = x0.sub(i2).add(C.yyy).toVar('x2')
+        const x3 = x0.sub(D.yyy).toVar('x3')
+        i.assign(mod289Vec3(i))
+        const p = permuteVec4(
+                permuteVec4(
+                        permuteVec4(i.z.add(vec4(0, i1.z, i2.z, 1)))
+                                .add(i.y)
+                                .add(vec4(0, i1.y, i2.y, 1))
+                )
+                        .add(i.x)
+                        .add(vec4(0, i1.x, i2.x, 1))
+        ).toVar('p')
+        const n_ = float(0.142857142857).toVar('n_')
+        const ns = n_.mul(D.wyz).sub(D.xzx).toVar('ns')
+        const j = p.sub(p.mul(ns.z).mul(ns.z).floor().mul(49)).toVar('j')
+        const x_ = j.mul(ns.z).floor().toVar('x_')
+        const y_ = j.sub(x_.mul(7)).floor().toVar('y_')
+        const x = x_.mul(ns.x).add(ns.yyyy).toVar('x')
+        const y = y_.mul(ns.x).add(ns.yyyy).toVar('y')
+        const h = float(1).sub(x.abs()).sub(y.abs()).toVar('h')
+        const b0 = vec4(x.xy, y.xy).toVar('b0')
+        const b1 = vec4(x.zw, y.zw).toVar('b1')
+        const s0 = b0.floor().mul(2).add(1).toVar('s0')
+        const s1 = b1.floor().mul(2).add(1).toVar('s1')
+        const sh = vec4(0).step(h).negate().toVar('sh')
+        const a0 = b0.xzyw.add(s0.xzyw.mul(sh.xxyy)).toVar('a0')
+        const a1 = b1.xzyw.add(s1.xzyw.mul(sh.zzww)).toVar('a1')
+        const p0 = vec3(a0.xy, h.x).toVar('p0')
+        const p1 = vec3(a0.zw, h.y).toVar('p1')
+        const p2 = vec3(a1.xy, h.z).toVar('p2')
+        const p3 = vec3(a1.zw, h.w).toVar('p3')
+        const norm = taylorInvSqrt(vec4(p0.dot(p0), p1.dot(p1), p2.dot(p2), p3.dot(p3))).toVar('norm')
+        p0.mulAssign(norm.x)
+        p1.mulAssign(norm.y)
+        p2.mulAssign(norm.z)
+        p3.mulAssign(norm.w)
+        const m = float(0.6)
+                .sub(vec4(x0.dot(x0), x1.dot(x1), x2.dot(x2), x3.dot(x3)))
+                .max(0)
+                .toVar('m')
+        m.assign(m.mul(m))
+        return float(42).mul(m.mul(m).dot(vec4(p0.dot(x0), p1.dot(x1), p2.dot(x2), p3.dot(x3))))
+}).setLayout({
+        name: 'snoiseVec3',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})
+
+export const snoiseVec4 = Fn(([v]: [Vec4]): Float => {
+        const C = vec4(0.138196601125011, 0.276393202250021, 0.414589803375032, -0.447213595499958).toVar('C')
+        const i = v
+                .add(v.dot(vec4(0.309016994374947451)))
+                .floor()
+                .toVar('i')
+        const x0 = v.sub(i).add(i.dot(C.xxxx)).toVar('x0')
+        const i0 = vec4(0).toVar('i0')
+        const isX = x0.xxx.step(x0.yzw).toVar('isX')
+        const isYZ = x0.yyz.step(x0.zww).toVar('isYZ')
+        i0.x = isX.x.add(isX.y).add(isX.z)
+        i0.yzw = float(1).sub(isX)
+        i0.y = i0.y.add(isYZ.x).add(isYZ.y)
+        i0.zw = i0.zw.add(float(1).sub(isYZ.xy))
+        i0.z = i0.z.add(isYZ.z)
+        i0.w = i0.w.add(float(1).sub(isYZ.z))
+        const i3 = i0.clamp(0, 1).toVar('i3')
+        const i2 = i0.sub(1).clamp(0, 1).toVar('i2')
+        const i1 = i0.sub(2).clamp(0, 1).toVar('i1')
+        const x1 = x0.sub(i1).add(C.xxxx).toVar('x1')
+        const x2 = x0.sub(i2).add(C.yyyy).toVar('x2')
+        const x3 = x0.sub(i3).add(C.zzzz).toVar('x3')
+        const x4 = x0.add(C.wwww).toVar('x4')
+        i.assign(mod289Vec4(i))
+        const j0 = permute(permute(permute(permute(i.w).add(i.z)).add(i.y)).add(i.x)).toVar('j0')
+        const j1 = permuteVec4(
+                permuteVec4(
+                        permuteVec4(
+                                permuteVec4(i.w.add(vec4(i1.w, i2.w, i3.w, 1)))
+                                        .add(i.z)
+                                        .add(vec4(i1.z, i2.z, i3.z, 1))
+                        )
+                                .add(i.y)
+                                .add(vec4(i1.y, i2.y, i3.y, 1))
+                )
+                        .add(i.x)
+                        .add(vec4(i1.x, i2.x, i3.x, 1))
+        ).toVar('j1')
+        const ip = vec4(1 / 294, 1 / 49, 1 / 7, 0).toVar('ip')
+        const p0 = grad4(j0, ip).toVar('p0')
+        const p1 = grad4(j1.x, ip).toVar('p1')
+        const p2 = grad4(j1.y, ip).toVar('p2')
+        const p3 = grad4(j1.z, ip).toVar('p3')
+        const p4 = grad4(j1.w, ip).toVar('p4')
+        const norm = taylorInvSqrt(vec4(p0.dot(p0), p1.dot(p1), p2.dot(p2), p3.dot(p3))).toVar('norm')
+        p0.mulAssign(norm.x)
+        p1.mulAssign(norm.y)
+        p2.mulAssign(norm.z)
+        p3.mulAssign(norm.w)
+        p4.mulAssign(taylorInvSqrt(p4.dot(p4)))
+        const m0 = float(0.6)
+                .sub(vec3(x0.dot(x0), x1.dot(x1), x2.dot(x2)))
+                .max(0)
+                .toVar('m0')
+        const m1 = float(0.6)
+                .sub(vec2(x3.dot(x3), x4.dot(x4)))
+                .max(0)
+                .toVar('m1')
+        m0.assign(m0.mul(m0))
+        m1.assign(m1.mul(m1))
+        return float(49).mul(
+                m0
+                        .mul(m0)
+                        .dot(vec3(p0.dot(x0), p1.dot(x1), p2.dot(x2)))
+                        .add(m1.mul(m1).dot(vec2(p3.dot(x3), p4.dot(x4))))
+        )
+}).setLayout({
+        name: 'snoiseVec4',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec4' }],
+})
+
+export const snoise2 = Fn(([x]: [Vec2]): Vec2 => {
+        const s = snoiseVec2(x).toVar('s')
+        const s1 = snoiseVec2(vec2(x.y.sub(19.1), x.x.add(47.2))).toVar('s1')
+        return vec2(s, s1)
+}).setLayout({
+        name: 'snoise2',
+        type: 'vec2',
+        inputs: [{ name: 'x', type: 'vec2' }],
+})
+
+export const snoise3Vec3 = Fn(([x]: [Vec3]): Vec3 => {
+        const s = snoiseVec3(x).toVar('s')
+        const s1 = snoiseVec3(vec3(x.y.sub(19.1), x.z.add(33.4), x.x.add(47.2))).toVar('s1')
+        const s2 = snoiseVec3(vec3(x.z.add(74.2), x.x.sub(124.5), x.y.add(99.4))).toVar('s2')
+        return vec3(s, s1, s2)
+}).setLayout({
+        name: 'snoise3Vec3',
+        type: 'vec3',
+        inputs: [{ name: 'x', type: 'vec3' }],
+})
+
+export const snoise3Vec4 = Fn(([x]: [Vec4]): Vec3 => {
+        const s = snoiseVec4(x).toVar('s')
+        const s1 = snoiseVec4(vec4(x.y.sub(19.1), x.z.add(33.4), x.x.add(47.2), x.w)).toVar('s1')
+        const s2 = snoiseVec4(vec4(x.z.add(74.2), x.x.sub(124.5), x.y.add(99.4), x.w)).toVar('s2')
+        return vec3(s, s1, s2)
+}).setLayout({
+        name: 'snoise3Vec4',
+        type: 'vec3',
+        inputs: [{ name: 'x', type: 'vec4' }],
+})

package/src/addons/generative/srandom.ts

@@ -0,0 +1,90 @@
+import { Fn, Float, Vec2, Vec3, Vec4, vec2, vec3, vec4, float, dot, sin } from '../../node'
+
+export const srandom = Fn(([x]: [Float]): Float => {
+        return float(-1).add(float(2).mul(x.sin().mul(43758.5453).fract()))
+}).setLayout({
+        name: 'srandom',
+        type: 'float',
+        inputs: [{ name: 'x', type: 'float' }],
+})
+
+export const srandomVec2 = Fn(([st]: [Vec2]): Float => {
+        return float(-1).add(float(2).mul(st.dot(vec2(12.9898, 78.233)).sin().mul(43758.5453).fract()))
+}).setLayout({
+        name: 'srandomVec2',
+        type: 'float',
+        inputs: [{ name: 'st', type: 'vec2' }],
+})
+
+export const srandomVec3 = Fn(([pos]: [Vec3]): Float => {
+        return float(-1).add(float(2).mul(pos.dot(vec3(70.9898, 78.233, 32.4355)).sin().mul(43758.5453123).fract()))
+}).setLayout({
+        name: 'srandomVec3',
+        type: 'float',
+        inputs: [{ name: 'pos', type: 'vec3' }],
+})
+
+export const srandomVec4 = Fn(([pos]: [Vec4]): Float => {
+        const dot_product = pos.dot(vec4(12.9898, 78.233, 45.164, 94.673)).toVar('dot_product')
+        return float(-1).add(float(2).mul(dot_product.sin().mul(43758.5453).fract()))
+}).setLayout({
+        name: 'srandomVec4',
+        type: 'float',
+        inputs: [{ name: 'pos', type: 'vec4' }],
+})
+
+export const srandom2Vec2 = Fn(([st]: [Vec2]): Vec2 => {
+        const k = vec2(0.3183099, 0.3678794).toVar('k')
+        st.assign(st.mul(k).add(k.yx))
+        return vec2(-1).add(
+                vec2(2).mul(
+                        float(16)
+                                .mul(k)
+                                .mul(st.x.mul(st.y).mul(st.x.add(st.y)).fract())
+                                .fract()
+                )
+        )
+}).setLayout({
+        name: 'srandom2Vec2',
+        type: 'vec2',
+        inputs: [{ name: 'st', type: 'vec2' }],
+})
+
+export const srandom3Vec3 = Fn(([p]: [Vec3]): Vec3 => {
+        p.assign(
+                vec3(
+                        p.dot(vec3(127.1, 311.7, 74.7)),
+                        p.dot(vec3(269.5, 183.3, 246.1)),
+                        p.dot(vec3(113.5, 271.9, 124.6))
+                )
+        )
+        return float(-1).add(float(2).mul(p.sin().mul(43758.5453123).fract()))
+}).setLayout({
+        name: 'srandom3Vec3',
+        type: 'vec3',
+        inputs: [{ name: 'p', type: 'vec3' }],
+})
+
+export const srandom2Vec2Tiled = Fn(([p, tileLength]: [Vec2, Float]): Vec2 => {
+        p.assign(p.mod(vec2(tileLength)))
+        return srandom2Vec2(p)
+}).setLayout({
+        name: 'srandom2Vec2Tiled',
+        type: 'vec2',
+        inputs: [
+                { name: 'p', type: 'vec2' },
+                { name: 'tileLength', type: 'float' },
+        ],
+})
+
+export const srandom3Vec3Tiled = Fn(([p, tileLength]: [Vec3, Float]): Vec3 => {
+        p.assign(p.mod(vec3(tileLength)))
+        return srandom3Vec3(p)
+}).setLayout({
+        name: 'srandom3Vec3Tiled',
+        type: 'vec3',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'tileLength', type: 'float' },
+        ],
+})

package/src/addons/generative/voronoi.ts

@@ -0,0 +1,134 @@
+import { Fn, Float, Vec2, Vec3, vec2, vec3, float, If } from '../../node'
+import { random2Vec2 } from './random'
+import { TAU } from '../math/const'
+
+export const voronoi = Fn(([uv, time]: [Vec2, Float]): Vec3 => {
+        const i_uv = uv.floor().toVar('i_uv')
+        const f_uv = uv.fract().toVar('f_uv')
+        const rta = vec3(0, 0, 10).toVar('rta')
+
+        // Unroll nested loop: for j=-1 to 1, for i=-1 to 1
+        // j=-1, i=-1
+        const neighbor_m1m1 = vec2(-1, -1).toVar('neighbor_m1m1')
+        const point_m1m1 = random2Vec2(i_uv.add(neighbor_m1m1)).toVar('point_m1m1')
+        point_m1m1.assign(float(0.5).add(float(0.5).mul(time.add(point_m1m1.mul(TAU)).sin())))
+        const diff_m1m1 = neighbor_m1m1.add(point_m1m1).sub(f_uv).toVar('diff_m1m1')
+        const dist_m1m1 = diff_m1m1.length().toVar('dist_m1m1')
+        If(dist_m1m1.lessThan(rta.z), () => {
+                rta.xy.assign(point_m1m1)
+                rta.z.assign(dist_m1m1)
+        })
+
+        // j=-1, i=0
+        const neighbor_0m1 = vec2(0, -1).toVar('neighbor_0m1')
+        const point_0m1 = random2Vec2(i_uv.add(neighbor_0m1)).toVar('point_0m1')
+        point_0m1.assign(float(0.5).add(float(0.5).mul(time.add(point_0m1.mul(TAU)).sin())))
+        const diff_0m1 = neighbor_0m1.add(point_0m1).sub(f_uv).toVar('diff_0m1')
+        const dist_0m1 = diff_0m1.length().toVar('dist_0m1')
+        If(dist_0m1.lessThan(rta.z), () => {
+                rta.xy.assign(point_0m1)
+                rta.z.assign(dist_0m1)
+        })
+
+        // j=-1, i=1
+        const neighbor_1m1 = vec2(1, -1).toVar('neighbor_1m1')
+        const point_1m1 = random2Vec2(i_uv.add(neighbor_1m1)).toVar('point_1m1')
+        point_1m1.assign(float(0.5).add(float(0.5).mul(time.add(point_1m1.mul(TAU)).sin())))
+        const diff_1m1 = neighbor_1m1.add(point_1m1).sub(f_uv).toVar('diff_1m1')
+        const dist_1m1 = diff_1m1.length().toVar('dist_1m1')
+        If(dist_1m1.lessThan(rta.z), () => {
+                rta.xy.assign(point_1m1)
+                rta.z.assign(dist_1m1)
+        })
+
+        // j=0, i=-1
+        const neighbor_m10 = vec2(-1, 0).toVar('neighbor_m10')
+        const point_m10 = random2Vec2(i_uv.add(neighbor_m10)).toVar('point_m10')
+        point_m10.assign(float(0.5).add(float(0.5).mul(time.add(point_m10.mul(TAU)).sin())))
+        const diff_m10 = neighbor_m10.add(point_m10).sub(f_uv).toVar('diff_m10')
+        const dist_m10 = diff_m10.length().toVar('dist_m10')
+        If(dist_m10.lessThan(rta.z), () => {
+                rta.xy.assign(point_m10)
+                rta.z.assign(dist_m10)
+        })
+
+        // j=0, i=0
+        const neighbor_00 = vec2(0, 0).toVar('neighbor_00')
+        const point_00 = random2Vec2(i_uv.add(neighbor_00)).toVar('point_00')
+        point_00.assign(float(0.5).add(float(0.5).mul(time.add(point_00.mul(TAU)).sin())))
+        const diff_00 = neighbor_00.add(point_00).sub(f_uv).toVar('diff_00')
+        const dist_00 = diff_00.length().toVar('dist_00')
+        If(dist_00.lessThan(rta.z), () => {
+                rta.xy.assign(point_00)
+                rta.z.assign(dist_00)
+        })
+
+        // j=0, i=1
+        const neighbor_10 = vec2(1, 0).toVar('neighbor_10')
+        const point_10 = random2Vec2(i_uv.add(neighbor_10)).toVar('point_10')
+        point_10.assign(float(0.5).add(float(0.5).mul(time.add(point_10.mul(TAU)).sin())))
+        const diff_10 = neighbor_10.add(point_10).sub(f_uv).toVar('diff_10')
+        const dist_10 = diff_10.length().toVar('dist_10')
+        If(dist_10.lessThan(rta.z), () => {
+                rta.xy.assign(point_10)
+                rta.z.assign(dist_10)
+        })
+
+        // j=1, i=-1
+        const neighbor_m11 = vec2(-1, 1).toVar('neighbor_m11')
+        const point_m11 = random2Vec2(i_uv.add(neighbor_m11)).toVar('point_m11')
+        point_m11.assign(float(0.5).add(float(0.5).mul(time.add(point_m11.mul(TAU)).sin())))
+        const diff_m11 = neighbor_m11.add(point_m11).sub(f_uv).toVar('diff_m11')
+        const dist_m11 = diff_m11.length().toVar('dist_m11')
+        If(dist_m11.lessThan(rta.z), () => {
+                rta.xy.assign(point_m11)
+                rta.z.assign(dist_m11)
+        })
+
+        // j=1, i=0
+        const neighbor_01 = vec2(0, 1).toVar('neighbor_01')
+        const point_01 = random2Vec2(i_uv.add(neighbor_01)).toVar('point_01')
+        point_01.assign(float(0.5).add(float(0.5).mul(time.add(point_01.mul(TAU)).sin())))
+        const diff_01 = neighbor_01.add(point_01).sub(f_uv).toVar('diff_01')
+        const dist_01 = diff_01.length().toVar('dist_01')
+        If(dist_01.lessThan(rta.z), () => {
+                rta.xy.assign(point_01)
+                rta.z.assign(dist_01)
+        })
+
+        // j=1, i=1
+        const neighbor_11 = vec2(1, 1).toVar('neighbor_11')
+        const point_11 = random2Vec2(i_uv.add(neighbor_11)).toVar('point_11')
+        point_11.assign(float(0.5).add(float(0.5).mul(time.add(point_11.mul(TAU)).sin())))
+        const diff_11 = neighbor_11.add(point_11).sub(f_uv).toVar('diff_11')
+        const dist_11 = diff_11.length().toVar('dist_11')
+        If(dist_11.lessThan(rta.z), () => {
+                rta.xy.assign(point_11)
+                rta.z.assign(dist_11)
+        })
+
+        return rta
+}).setLayout({
+        name: 'voronoi',
+        type: 'vec3',
+        inputs: [
+                { name: 'uv', type: 'vec2' },
+                { name: 'time', type: 'float' },
+        ],
+})
+
+export const voronoiVec2 = Fn(([p]: [Vec2]): Vec3 => {
+        return voronoi(p, float(0))
+}).setLayout({
+        name: 'voronoiVec2',
+        type: 'vec3',
+        inputs: [{ name: 'p', type: 'vec2' }],
+})
+
+export const voronoiVec3 = Fn(([p]: [Vec3]): Vec3 => {
+        return voronoi(p.xy, p.z)
+}).setLayout({
+        name: 'voronoiVec3',
+        type: 'vec3',
+        inputs: [{ name: 'p', type: 'vec3' }],
+})

package/src/addons/generative/voronoise.ts

@@ -0,0 +1,69 @@
+import { Fn, Float, Vec2, Vec3, vec2, vec3, int, smoothstep, float, Loop } from '../../node'
+import { random3Vec2, random3Vec3 } from './random'
+
+export const voronoise = Fn(([p, u, v]: [Vec2, Float, Float]): Float => {
+        const k = float(1)
+                .add(float(63).mul(float(1).sub(v).pow(float(6))))
+                .toVar('k')
+        const i = p.floor().toVar('i')
+        const f = p.fract().toVar('f')
+        const a = vec2(0, 0).toVar('a')
+
+        // 5x5 grid sampling from -2 to +2
+        Loop(int(5), ({ i: yLoop }) => {
+                const yOffset = yLoop.sub(int(2)).toFloat().toVar('yOffset')
+                Loop(int(5), ({ i: xLoop }) => {
+                        const xOffset = xLoop.sub(int(2)).toFloat().toVar('xOffset')
+                        const g = vec2(xOffset, yOffset).toVar('g')
+                        const o = random3Vec2(i.add(g)).mul(vec3(u, u, 1)).toVar('o')
+                        const d = g.sub(f).add(o.xy).toVar('d')
+                        const w = float(1).sub(float(0).smoothstep(1.414, d.length())).pow(k).toVar('w')
+                        a.addAssign(vec2(o.z.mul(w), w))
+                })
+        })
+
+        return a.x.div(a.y)
+}).setLayout({
+        name: 'voronoise',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec2' },
+                { name: 'u', type: 'float' },
+                { name: 'v', type: 'float' },
+        ],
+})
+
+export const voronoiseVec3 = Fn(([p, u, v]: [Vec3, Float, Float]): Float => {
+        const k = float(1)
+                .add(float(63).mul(float(1).sub(v).pow(float(6))))
+                .toVar('k')
+        const i = p.floor().toVar('i')
+        const f = p.fract().toVar('f')
+        const a = vec2(0, 0).toVar('a')
+
+        // 5x5x5 grid sampling from -2 to +2
+        Loop(int(5), ({ i: zLoop }) => {
+                const zOffset = zLoop.sub(int(2)).toFloat().toVar('zOffset')
+                Loop(int(5), ({ i: yLoop }) => {
+                        const yOffset = yLoop.sub(int(2)).toFloat().toVar('yOffset')
+                        Loop(int(5), ({ i: xLoop }) => {
+                                const xOffset = xLoop.sub(int(2)).toFloat().toVar('xOffset')
+                                const g = vec3(xOffset, yOffset, zOffset).toVar('g')
+                                const o = random3Vec3(i.add(g)).mul(vec3(u, u, 1)).toVar('o')
+                                const d = g.sub(f).add(o).add(0.5).toVar('d')
+                                const w = float(1).sub(float(0).smoothstep(1.414, d.length())).pow(k).toVar('w')
+                                a.addAssign(vec2(o.z.mul(w), w))
+                        })
+                })
+        })
+
+        return a.x.div(a.y)
+}).setLayout({
+        name: 'voronoiseVec3',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'u', type: 'float' },
+                { name: 'v', type: 'float' },
+        ],
+})

package/src/addons/generative/wavelet.ts

@@ -0,0 +1,77 @@
+import { Fn, Float, Vec2, Vec3, Loop, int, float, mat2 } from '../../node'
+import { randomVec2 } from './random'
+import { rotate2d } from '../math/rotate2d'
+
+export const wavelet = Fn(([p, phase, k]: [Vec2, Float, Float]): Float => {
+        const d = float(0).toVar('d')
+        const s = float(1).toVar('s')
+        const m = float(0).toVar('m')
+
+        Loop(int(4), ({ i }) => {
+                const q = p.mul(s).toVar('q')
+                const a = randomVec2(q.floor()).mul(1000).toVar('a')
+
+                q.assign(q.fract().sub(0.5).mul(rotate2d(a)))
+
+                d.addAssign(
+                        q.x
+                                .mul(10)
+                                .add(phase)
+                                .sin()
+                                .mul(float(0.25).smoothstep(0, q.dot(q)))
+                                .div(s)
+                )
+
+                p.assign(p.mul(mat2(0.54, -0.84, 0.84, 0.54)).add(i.toFloat()))
+                m.addAssign(float(1).div(s))
+                s.mulAssign(k)
+        })
+
+        return d.div(m)
+}).setLayout({
+        name: 'wavelet',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec2' },
+                { name: 'phase', type: 'float' },
+                { name: 'k', type: 'float' },
+        ],
+})
+
+export const waveletVec3K = Fn(([p, k]: [Vec3, Float]): Float => {
+        return wavelet(p.xy, p.z, k)
+}).setLayout({
+        name: 'waveletVec3K',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'k', type: 'float' },
+        ],
+})
+
+export const waveletVec3 = Fn(([p]: [Vec3]): Float => {
+        return waveletVec3K(p, float(1.24))
+}).setLayout({
+        name: 'waveletVec3',
+        type: 'float',
+        inputs: [{ name: 'p', type: 'vec3' }],
+})
+
+export const waveletVec2Phase = Fn(([p, phase]: [Vec2, Float]): Float => {
+        return wavelet(p, phase, float(1.24))
+}).setLayout({
+        name: 'waveletVec2Phase',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec2' },
+                { name: 'phase', type: 'float' },
+        ],
+})
+
+export const waveletVec2 = Fn(([p]: [Vec2]): Float => {
+        return wavelet(p, float(0), float(1.24))
+}).setLayout({
+        name: 'waveletVec2',
+        type: 'float',
+        inputs: [{ name: 'p', type: 'vec2' }],
+})

package/src/addons/generative/worley.ts

@@ -0,0 +1,99 @@
+import { Fn, Float, Vec2, Vec3, Loop, int, float, vec2, vec3, If } from '../../node'
+import { random2Vec2, random3Vec3 } from './random'
+import { distEuclidean } from '../math/dist'
+
+export const worley2Vec2 = Fn(([p]: [Vec2]): Vec2 => {
+        const n = p.floor().toVar('n')
+        const f = p.fract().toVar('f')
+        const distF1 = float(1).toVar('distF1')
+        const distF2 = float(1).toVar('distF2')
+        const off1 = vec2(0).toVar('off1')
+        const pos1 = vec2(0).toVar('pos1')
+        const off2 = vec2(0).toVar('off2')
+        const pos2 = vec2(0).toVar('pos2')
+
+        Loop(int(3), ({ i }) => {
+                Loop(int(3), ({ i: j }) => {
+                        const g = vec2(i.toFloat().sub(1), j.toFloat().sub(1)).toVar('g')
+                        const o = random2Vec2(n.add(g)).mul(1).toVar('o')
+                        const point = g.add(o).toVar('point')
+                        const d = distEuclidean(point, f).toVar('d')
+
+                        If(d.lessThan(distF1), () => {
+                                distF2.assign(distF1)
+                                distF1.assign(d)
+                                off2.assign(off1)
+                                off1.assign(g)
+                                pos2.assign(pos1)
+                                pos1.assign(point)
+                        }).ElseIf(d.lessThan(distF2), () => {
+                                distF2.assign(d)
+                                off2.assign(g)
+                                pos2.assign(point)
+                        })
+                })
+        })
+
+        return vec2(distF1, distF2)
+}).setLayout({
+        name: 'worley2Vec2',
+        type: 'vec2',
+        inputs: [{ name: 'p', type: 'vec2' }],
+})
+
+export const worleyVec2 = Fn(([p]: [Vec2]): Float => {
+        return float(1).sub(worley2Vec2(p).x)
+}).setLayout({
+        name: 'worleyVec2',
+        type: 'float',
+        inputs: [{ name: 'p', type: 'vec2' }],
+})
+
+export const worley2Vec3 = Fn(([p]: [Vec3]): Vec2 => {
+        const n = p.floor().toVar('n')
+        const f = p.fract().toVar('f')
+        const distF1 = float(1).toVar('distF1')
+        const distF2 = float(1).toVar('distF2')
+        const off1 = vec3(0).toVar('off1')
+        const pos1 = vec3(0).toVar('pos1')
+        const off2 = vec3(0).toVar('off2')
+        const pos2 = vec3(0).toVar('pos2')
+
+        Loop(int(3), ({ i }) => {
+                Loop(int(3), ({ i: j }) => {
+                        Loop(int(3), ({ i: k }) => {
+                                const g = vec3(i.toFloat().sub(1), j.toFloat().sub(1), k.toFloat().sub(1)).toVar('g')
+                                const o = random3Vec3(n.add(g)).mul(1).toVar('o')
+                                const point = g.add(o).toVar('point')
+                                const d = distEuclidean(point, f).toVar('d')
+
+                                If(d.lessThan(distF1), () => {
+                                        distF2.assign(distF1)
+                                        distF1.assign(d)
+                                        off2.assign(off1)
+                                        off1.assign(g)
+                                        pos2.assign(pos1)
+                                        pos1.assign(point)
+                                }).ElseIf(d.lessThan(distF2), () => {
+                                        distF2.assign(d)
+                                        off2.assign(g)
+                                        pos2.assign(point)
+                                })
+                        })
+                })
+        })
+
+        return vec2(distF1, distF2)
+}).setLayout({
+        name: 'worley2Vec3',
+        type: 'vec2',
+        inputs: [{ name: 'p', type: 'vec3' }],
+})
+
+export const worleyVec3 = Fn(([p]: [Vec3]): Float => {
+        return float(1).sub(worley2Vec3(p).x)
+}).setLayout({
+        name: 'worleyVec3',
+        type: 'float',
+        inputs: [{ name: 'p', type: 'vec3' }],
+})

package/src/addons/geometry/aabb/aabb.ts

@@ -0,0 +1,8 @@
+import { struct, vec3 } from '../../../node'
+
+export const AABB = struct({
+        minBounds: vec3(),
+        maxBounds: vec3(),
+})
+
+export type AABBType = ReturnType<typeof AABB>