glre 0.39.0 → 0.40.0

package/src/addons/generative/psrdnoise.ts

@@ -0,0 +1,277 @@
+import { Fn, Float, Vec2, Vec3, vec2, vec3, vec4, mat3, step, mix, If, float, any } from '../../node'
+import { mod289Vec3 } from '../math/mod289'
+import { permuteVec4 } from '../math/permute'
+
+// Basic psrdnoise 2D implementation
+export const psrdnoise2D = Fn(([x, period, alpha]: [Vec2, Vec2, Float]): Vec2 => {
+        const uv = vec2(x.x.add(x.y.div(2)), x.y).toVar('uv')
+        const i0 = uv.floor().toVar('i0')
+        const f0 = uv.fract().toVar('f0')
+        const cmp = f0.x.step(f0.y).toVar('cmp')
+        const o1 = vec2(cmp, cmp.oneMinus()).toVar('o1')
+        const i1 = i0.add(o1).toVar('i1')
+        const i2 = i0.add(vec2(1, 1)).toVar('i2')
+
+        const v0 = vec2(i0.x.sub(i0.y.div(2)), i0.y).toVar('v0')
+        const v1 = vec2(v0.x.add(o1.x).sub(o1.y.div(2)), v0.y.add(o1.y)).toVar('v1')
+        const v2 = vec2(v0.x.add(0.5), v0.y.add(1)).toVar('v2')
+
+        const x0 = x.sub(v0).toVar('x0')
+        const x1 = x.sub(v1).toVar('x1')
+        const x2 = x.sub(v2).toVar('x2')
+
+        let iu = vec3(i0.x, i1.x, i2.x).toVar('iu')
+        let iv = vec3(i0.y, i1.y, i2.y).toVar('iv')
+
+        If(period.x.greaterThan(0).or(period.y.greaterThan(0)), () => {
+                const xw = vec3(v0.x, v1.x, v2.x).toVar('xw')
+                const yw = vec3(v0.y, v1.y, v2.y).toVar('yw')
+
+                If(period.x.greaterThan(0), () => {
+                        xw.assign(xw.mod(period.x))
+                })
+
+                If(period.y.greaterThan(0), () => {
+                        yw.assign(yw.mod(period.y))
+                })
+
+                iu.assign(xw.add(yw.div(2)).add(0.5).floor())
+                iv.assign(yw.add(0.5).floor())
+        })
+
+        let hash = mod289Vec3(iu).toVar('hash')
+        hash.assign(mod289Vec3(hash.mul(51).add(2).mul(hash).add(iv)))
+        hash.assign(mod289Vec3(hash.mul(34).add(10).mul(hash)))
+
+        const psi = hash.mul(0.07482).add(alpha).toVar('psi')
+        const gx = psi.cos().toVar('gx')
+        const gy = psi.sin().toVar('gy')
+
+        const g0 = vec2(gx.x, gy.x).toVar('g0')
+        const g1 = vec2(gx.y, gy.y).toVar('g1')
+        const g2 = vec2(gx.z, gy.z).toVar('g2')
+
+        const w = vec3(0.8)
+                .sub(vec3(x0.dot(x0), x1.dot(x1), x2.dot(x2)))
+                .toVar('w')
+        w.assign(w.max(0))
+
+        const w2 = w.mul(w).toVar('w2')
+        const w4 = w2.mul(w2).toVar('w4')
+        const gdotx = vec3(g0.dot(x0), g1.dot(x1), g2.dot(x2)).toVar('gdotx')
+        const n = w4.dot(gdotx).toVar('n')
+
+        const w3 = w2.mul(w).toVar('w3')
+        const dw = w3.mul(-8).mul(gdotx).toVar('dw')
+        const dn0 = g0.mul(w4.x).add(x0.mul(dw.x)).toVar('dn0')
+        const dn1 = g1.mul(w4.y).add(x1.mul(dw.y)).toVar('dn1')
+        const dn2 = g2.mul(w4.z).add(x2.mul(dw.z)).toVar('dn2')
+        const gradient = dn0.add(dn1).add(dn2).mul(10.9).toVar('gradient')
+
+        return vec2(n.mul(10.9), gradient.length())
+}).setLayout({
+        name: 'psrdnoise2D',
+        type: 'vec2',
+        inputs: [
+                { name: 'x', type: 'vec2' },
+                { name: 'period', type: 'vec2' },
+                { name: 'alpha', type: 'float' },
+        ],
+})
+
+// Basic psrdnoise 3D implementation
+export const psrdnoise3D = Fn(([x, period, alpha]: [Vec3, Vec3, Float]): Vec3 => {
+        const M = mat3(0, 1, 1, 1, 0, 1, 1, 1, 0).toVar('M')
+        const Mi = mat3(-0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, -0.5).toVar('Mi')
+
+        const uvw = M.mul(x).toVar('uvw')
+        const i0 = uvw.floor().toVar('i0')
+        const f0 = uvw.fract().toVar('f0')
+
+        const g_ = f0.yzz.step(f0.xyx).toVar('g_')
+        const l_ = g_.oneMinus().toVar('l_')
+        const g = vec3(l_.z, g_.xy).toVar('g')
+        const l = vec3(l_.xy, g_.z).toVar('l')
+
+        const o1 = g.min(l).toVar('o1')
+        const o2 = g.max(l).toVar('o2')
+
+        const i1 = i0.add(o1).toVar('i1')
+        const i2 = i0.add(o2).toVar('i2')
+        const i3 = i0.add(vec3(1)).toVar('i3')
+
+        let v0 = Mi.mul(i0).toVar('v0')
+        let v1 = Mi.mul(i1).toVar('v1')
+        let v2 = Mi.mul(i2).toVar('v2')
+        let v3 = Mi.mul(i3).toVar('v3')
+
+        const x0 = x.sub(v0).toVar('x0')
+        const x1 = x.sub(v1).toVar('x1')
+        const x2 = x.sub(v2).toVar('x2')
+        const x3 = x.sub(v3).toVar('x3')
+
+        If(period.x.greaterThan(0).or(period.y.greaterThan(0)).or(period.z.greaterThan(0)), () => {
+                const vx = vec4(v0.x, v1.x, v2.x, v3.x).toVar('vx')
+                const vy = vec4(v0.y, v1.y, v2.y, v3.y).toVar('vy')
+                const vz = vec4(v0.z, v1.z, v2.z, v3.z).toVar('vz')
+
+                If(period.x.greaterThan(0), () => vx.assign(vx.mod(period.x)))
+                If(period.y.greaterThan(0), () => vy.assign(vy.mod(period.y)))
+                If(period.z.greaterThan(0), () => vz.assign(vz.mod(period.z)))
+
+                i0.assign(M.mul(vec3(vx.x, vy.x, vz.x)))
+                i1.assign(M.mul(vec3(vx.y, vy.y, vz.y)))
+                i2.assign(M.mul(vec3(vx.z, vy.z, vz.z)))
+                i3.assign(M.mul(vec3(vx.w, vy.w, vz.w)))
+
+                i0.assign(i0.add(0.5).floor())
+                i1.assign(i1.add(0.5).floor())
+                i2.assign(i2.add(0.5).floor())
+                i3.assign(i3.add(0.5).floor())
+        })
+
+        const hash = permuteVec4(
+                permuteVec4(permuteVec4(vec4(i0.z, i1.z, i2.z, i3.z)).add(vec4(i0.y, i1.y, i2.y, i3.y))).add(
+                        vec4(i0.x, i1.x, i2.x, i3.x)
+                )
+        ).toVar('hash')
+
+        const theta = hash.mul(3.883222077).toVar('theta')
+        const sz = hash.mul(-0.006920415).add(0.996539792).toVar('sz')
+        const psi = hash.mul(0.108705628).toVar('psi')
+
+        const Ct = theta.cos().toVar('Ct')
+        const St = theta.sin().toVar('St')
+        const sz_prime = sz.mul(sz).oneMinus().sqrt().toVar('sz_prime')
+
+        const gx = Ct.mul(sz_prime).toVar('gx')
+        const gy = St.mul(sz_prime).toVar('gy')
+        const gz = sz.toVar('gz')
+
+        If(alpha.notEqual(0), () => {
+                const Sp = psi.sin().toVar('Sp')
+                const Cp = psi.cos().toVar('Cp')
+                const px = Ct.mul(sz_prime).toVar('px')
+                const py = St.mul(sz_prime).toVar('py')
+                const pz = sz.toVar('pz')
+
+                const Ctp = St.mul(Sp).sub(Ct.mul(Cp)).toVar('Ctp')
+                const qx = Ctp.mul(St).mix(Sp, sz).toVar('qx')
+                const qy = Ctp.negate().mul(Ct).mix(Cp, sz).toVar('qy')
+                const qz = py.mul(Cp).add(px.mul(Sp)).negate().toVar('qz')
+
+                const Sa = vec4(alpha.sin()).toVar('Sa')
+                const Ca = vec4(alpha.cos()).toVar('Ca')
+
+                gx.assign(Ca.mul(px).add(Sa.mul(qx)))
+                gy.assign(Ca.mul(py).add(Sa.mul(qy)))
+                gz.assign(Ca.mul(pz).add(Sa.mul(qz)))
+        })
+
+        const g0 = vec3(gx.x, gy.x, gz.x).toVar('g0')
+        const g1 = vec3(gx.y, gy.y, gz.y).toVar('g1')
+        const g2 = vec3(gx.z, gy.z, gz.z).toVar('g2')
+        const g3 = vec3(gx.w, gy.w, gz.w).toVar('g3')
+
+        let w = vec4(0.5)
+                .sub(vec4(x0.dot(x0), x1.dot(x1), x2.dot(x2), x3.dot(x3)))
+                .toVar('w')
+        w.assign(w.max(0))
+
+        const w2 = w.mul(w).toVar('w2')
+        const w3 = w2.mul(w).toVar('w3')
+        const gdotx = vec4(g0.dot(x0), g1.dot(x1), g2.dot(x2), g3.dot(x3)).toVar('gdotx')
+        const n = w3.dot(gdotx).toVar('n')
+
+        const dw = w2.mul(-6).mul(gdotx).toVar('dw')
+        const dn0 = g0.mul(w3.x).add(x0.mul(dw.x)).toVar('dn0')
+        const dn1 = g1.mul(w3.y).add(x1.mul(dw.y)).toVar('dn1')
+        const dn2 = g2.mul(w3.z).add(x2.mul(dw.z)).toVar('dn2')
+        const dn3 = g3.mul(w3.w).add(x3.mul(dw.w)).toVar('dn3')
+        const gradient = dn0.add(dn1).add(dn2).add(dn3).mul(39.5).toVar('gradient')
+
+        return vec3(n.mul(39.5), gradient.xy)
+}).setLayout({
+        name: 'psrdnoise3D',
+        type: 'vec3',
+        inputs: [
+                { name: 'x', type: 'vec3' },
+                { name: 'period', type: 'vec3' },
+                { name: 'alpha', type: 'float' },
+        ],
+})
+
+// Simplified overloads
+export const psrdnoise = Fn(([x]: [Vec2]): Float => {
+        return psrdnoise2D(x, vec2(0), float(0)).x
+}).setLayout({
+        name: 'psrdnoise',
+        type: 'float',
+        inputs: [{ name: 'x', type: 'vec2' }],
+})
+
+// Two-parameter overload for compatibility
+export const psrdnoise2 = Fn(([x, period]: [Vec2, Vec2]): Float => {
+        return psrdnoise2D(x, period, float(0)).x
+}).setLayout({
+        name: 'psrdnoise2',
+        type: 'float',
+        inputs: [
+                { name: 'x', type: 'vec2' },
+                { name: 'period', type: 'vec2' },
+        ],
+})
+
+export const psrdnoisePeriod = Fn(([x, period]: [Vec2, Vec2]): Float => {
+        return psrdnoise2D(x, period, float(0)).x
+}).setLayout({
+        name: 'psrdnoisePeriod',
+        type: 'float',
+        inputs: [
+                { name: 'x', type: 'vec2' },
+                { name: 'period', type: 'vec2' },
+        ],
+})
+
+export const psrdnoiseAlpha = Fn(([x, period, alpha]: [Vec2, Vec2, Float]): Float => {
+        return psrdnoise2D(x, period, alpha).x
+}).setLayout({
+        name: 'psrdnoiseAlpha',
+        type: 'float',
+        inputs: [
+                { name: 'x', type: 'vec2' },
+                { name: 'period', type: 'vec2' },
+                { name: 'alpha', type: 'float' },
+        ],
+})
+
+export const psrdnoise3 = Fn(([x]: [Vec3]): Float => {
+        return psrdnoise3D(x, vec3(0), float(0)).x
+}).setLayout({
+        name: 'psrdnoise3',
+        type: 'float',
+        inputs: [{ name: 'x', type: 'vec3' }],
+})
+
+export const psrdnoise3Period = Fn(([x, period]: [Vec3, Vec3]): Float => {
+        return psrdnoise3D(x, period, float(0)).x
+}).setLayout({
+        name: 'psrdnoise3Period',
+        type: 'float',
+        inputs: [
+                { name: 'x', type: 'vec3' },
+                { name: 'period', type: 'vec3' },
+        ],
+})
+
+export const psrdnoise3Alpha = Fn(([x, period, alpha]: [Vec3, Vec3, Float]): Float => {
+        return psrdnoise3D(x, period, alpha).x
+}).setLayout({
+        name: 'psrdnoise3Alpha',
+        type: 'float',
+        inputs: [
+                { name: 'x', type: 'vec3' },
+                { name: 'period', type: 'vec3' },
+                { name: 'alpha', type: 'float' },
+        ],
+})

package/src/addons/generative/random.ts

@@ -0,0 +1,136 @@
+import { Fn, Float, Vec2, Vec3, Vec4, vec2, vec3, vec4, float, dot, fract, sin } from '../../node'
+
+const RANDOM_SCALE = vec4(443.897, 441.423, 0.0973, 0.1099)
+
+export const random = Fn(([x]: [Float]): Float => {
+        return x.sin().mul(43758.5453).fract()
+}).setLayout({
+        name: 'random',
+        type: 'float',
+        inputs: [{ name: 'x', type: 'float' }],
+})
+
+export const randomVec2 = Fn(([st]: [Vec2]): Float => {
+        return st.dot(vec2(12.9898, 78.233)).sin().mul(43758.5453).fract()
+}).setLayout({
+        name: 'randomVec2',
+        type: 'float',
+        inputs: [{ name: 'st', type: 'vec2' }],
+})
+
+export const randomVec3 = Fn(([pos]: [Vec3]): Float => {
+        return pos.dot(vec3(70.9898, 78.233, 32.4355)).sin().mul(43758.5453123).fract()
+}).setLayout({
+        name: 'randomVec3',
+        type: 'float',
+        inputs: [{ name: 'pos', type: 'vec3' }],
+})
+
+export const randomVec4 = Fn(([pos]: [Vec4]): Float => {
+        const dot_product = pos.dot(vec4(12.9898, 78.233, 45.164, 94.673)).toVar('dot_product')
+        return dot_product.sin().mul(43758.5453).fract()
+}).setLayout({
+        name: 'randomVec4',
+        type: 'float',
+        inputs: [{ name: 'pos', type: 'vec4' }],
+})
+
+export const random2Float = Fn(([p]: [Float]): Vec2 => {
+        const p3 = vec3(p).mul(RANDOM_SCALE.xyz).fract().toVar('p3')
+        p3.addAssign(p3.dot(p3.yzx.add(19.19)))
+        return p3.xx.add(p3.yz).mul(p3.zy).fract()
+}).setLayout({
+        name: 'random2Float',
+        type: 'vec2',
+        inputs: [{ name: 'p', type: 'float' }],
+})
+
+export const random2Vec2 = Fn(([p]: [Vec2]): Vec2 => {
+        const p3 = p.xyx.mul(RANDOM_SCALE.xyz).fract().toVar('p3')
+        p3.addAssign(p3.dot(p3.yzx.add(19.19)))
+        return p3.xx.add(p3.yz).mul(p3.zy).fract()
+}).setLayout({
+        name: 'random2Vec2',
+        type: 'vec2',
+        inputs: [{ name: 'p', type: 'vec2' }],
+})
+
+export const random2Vec3 = Fn(([p3]: [Vec3]): Vec2 => {
+        p3.assign(p3.mul(RANDOM_SCALE.xyz).fract())
+        p3.addAssign(p3.dot(p3.yzx.add(19.19)))
+        return p3.xx.add(p3.yz).mul(p3.zy).fract()
+}).setLayout({
+        name: 'random2Vec3',
+        type: 'vec2',
+        inputs: [{ name: 'p3', type: 'vec3' }],
+})
+
+export const random3Float = Fn(([p]: [Float]): Vec3 => {
+        const p3 = vec3(p).mul(RANDOM_SCALE.xyz).fract().toVar('p3')
+        p3.addAssign(p3.dot(p3.yzx.add(19.19)))
+        return p3.xxy.add(p3.yzz).mul(p3.zyx).fract()
+}).setLayout({
+        name: 'random3Float',
+        type: 'vec3',
+        inputs: [{ name: 'p', type: 'float' }],
+})
+
+export const random3Vec2 = Fn(([p]: [Vec2]): Vec3 => {
+        const p3 = vec3(p.xyx).mul(RANDOM_SCALE.xyz).fract().toVar('p3')
+        p3.addAssign(p3.dot(p3.yxz.add(19.19)))
+        return p3.xxy.add(p3.yzz).mul(p3.zyx).fract()
+}).setLayout({
+        name: 'random3Vec2',
+        type: 'vec3',
+        inputs: [{ name: 'p', type: 'vec2' }],
+})
+
+export const random3Vec3 = Fn(([p]: [Vec3]): Vec3 => {
+        p.assign(p.mul(RANDOM_SCALE.xyz).fract())
+        p.addAssign(p.dot(p.yxz.add(19.19)))
+        return p.xxy.add(p.yzz).mul(p.zyx).fract()
+}).setLayout({
+        name: 'random3Vec3',
+        type: 'vec3',
+        inputs: [{ name: 'p', type: 'vec3' }],
+})
+
+export const random4Float = Fn(([p]: [Float]): Vec4 => {
+        const p4 = float(p).mul(RANDOM_SCALE).fract().toVar('p4')
+        p4.addAssign(p4.dot(p4.wzxy.add(19.19)))
+        return p4.xxyz.add(p4.yzzw).mul(p4.zywx).fract()
+}).setLayout({
+        name: 'random4Float',
+        type: 'vec4',
+        inputs: [{ name: 'p', type: 'float' }],
+})
+
+export const random4Vec2 = Fn(([p]: [Vec2]): Vec4 => {
+        const p4 = p.xyxy.mul(RANDOM_SCALE).fract().toVar('p4')
+        p4.addAssign(p4.dot(p4.wzxy.add(19.19)))
+        return p4.xxyz.add(p4.yzzw).mul(p4.zywx).fract()
+}).setLayout({
+        name: 'random4Vec2',
+        type: 'vec4',
+        inputs: [{ name: 'p', type: 'vec2' }],
+})
+
+export const random4Vec3 = Fn(([p]: [Vec3]): Vec4 => {
+        const p4 = p.xyzx.mul(RANDOM_SCALE).fract().toVar('p4')
+        p4.addAssign(p4.dot(p4.wzxy.add(19.19)))
+        return p4.xxyz.add(p4.yzzw).mul(p4.zywx).fract()
+}).setLayout({
+        name: 'random4Vec3',
+        type: 'vec4',
+        inputs: [{ name: 'p', type: 'vec3' }],
+})
+
+export const random4Vec4 = Fn(([p4]: [Vec4]): Vec4 => {
+        p4.assign(p4.mul(RANDOM_SCALE).fract())
+        p4.addAssign(p4.dot(p4.wzxy.add(19.19)))
+        return p4.xxyz.add(p4.yzzw).mul(p4.zywx).fract()
+}).setLayout({
+        name: 'random4Vec4',
+        type: 'vec4',
+        inputs: [{ name: 'p4', type: 'vec4' }],
+})

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' }],
+})