glre 0.39.0 → 0.40.0

package/src/addons/generative/fbm.ts

@@ -0,0 +1,69 @@
+import { Fn, Float, Vec2, Vec3, float, Loop, int } from '../../node'
+import { snoiseVec2, snoiseVec3 } from './snoise'
+import { gnoiseVec3Tiled } from './gnoise'
+
+const FBM_OCTAVES = int(4)
+const FBM_SCALE_SCALAR = 2
+const FBM_AMPLITUDE_INITIAL = 0.5
+const FBM_AMPLITUDE_SCALAR = 0.5
+
+export const fbmVec2 = Fn(([st]: [Vec2]): Float => {
+        const value = float(0).toVar('value')
+        const amplitude = float(FBM_AMPLITUDE_INITIAL).toVar('amplitude')
+        const coord = st.toVar('coord')
+        Loop(FBM_OCTAVES, () => {
+                value.addAssign(amplitude.mul(snoiseVec2(coord)))
+                coord.mulAssign(FBM_SCALE_SCALAR)
+                amplitude.mulAssign(FBM_AMPLITUDE_SCALAR)
+        })
+        return value
+}).setLayout({
+        name: 'fbmVec2',
+        type: 'float',
+        inputs: [{ name: 'st', type: 'vec2' }],
+})
+
+export const fbmVec3 = Fn(([pos]: [Vec3]): Float => {
+        const value = float(0).toVar('value')
+        const amplitude = float(FBM_AMPLITUDE_INITIAL).toVar('amplitude')
+        const posVar = pos.toVar('posVar')
+        Loop(FBM_OCTAVES, () => {
+                value.addAssign(amplitude.mul(snoiseVec3(posVar)))
+                posVar.mulAssign(FBM_SCALE_SCALAR)
+                amplitude.mulAssign(FBM_AMPLITUDE_SCALAR)
+        })
+        return value
+}).setLayout({
+        name: 'fbmVec3',
+        type: 'float',
+        inputs: [{ name: 'pos', type: 'vec3' }],
+})
+
+export const fbmVec3Tiled = Fn(([p, tileLength]: [Vec3, Float]): Float => {
+        const persistence = float(0.5).toVar('persistence')
+        const lacunarity = float(2).toVar('lacunarity')
+        const amplitude = float(0.5).toVar('amplitude')
+        const total = float(0).toVar('total')
+        const normalization = float(0).toVar('normalization')
+        const pVar = p.toVar('pVar')
+        Loop(FBM_OCTAVES, () => {
+                const noiseValue = gnoiseVec3Tiled(pVar, tileLength.mul(lacunarity).div(2))
+                        .div(2)
+                        .add(0.5)
+                        .toVar('noiseValue')
+                total.addAssign(noiseValue.mul(amplitude))
+                normalization.addAssign(amplitude)
+                amplitude.mulAssign(persistence)
+                pVar.assign(pVar.mul(lacunarity))
+        })
+        return total.div(normalization)
+}).setLayout({
+        name: 'fbmVec3Tiled',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'tileLength', type: 'float' },
+        ],
+})
+
+export const fbm = fbmVec3

package/src/addons/generative/gerstnerWave.ts

@@ -0,0 +1,21 @@
+import { Fn, Vec2, Float, vec3, dot, sqrt, float } from '../../node'
+import { PI } from '../math/const'
+
+export const gerstnerWave = Fn(([_uv, _dir, _steepness, _wavelength, _time]: [Vec2, Vec2, Float, Float, Float]) => {
+        const k = PI.mul(2).div(_wavelength).toVar('k')
+        const c = float(9.8).div(k).sqrt().toVar('c')
+        const d = _dir.normalize().toVar('d')
+        const f = k.mul(_uv.dot(d).sub(c.mul(_time))).toVar('f')
+        const a = _steepness.div(k).toVar('a')
+        return vec3(d.x.mul(a.mul(f.cos())), a.mul(f.sin()), d.y.mul(a.mul(f.cos())))
+}).setLayout({
+        name: 'gerstnerWave',
+        type: 'vec3',
+        inputs: [
+                { name: '_uv', type: 'vec2' },
+                { name: '_dir', type: 'vec2' },
+                { name: '_steepness', type: 'float' },
+                { name: '_wavelength', type: 'float' },
+                { name: '_time', type: 'float' },
+        ],
+})

package/src/addons/generative/gnoise.ts

@@ -0,0 +1,113 @@
+import { Fn, Float, Vec2, Vec3, vec2, vec3, float } from '../../node'
+import { random, randomVec2, randomVec3 } from './random'
+import { srandom3Vec3Tiled } from './srandom'
+import { cubicVec2 } from '../math/cubic'
+import { quintic } from '../math/quintic'
+
+export const gnoise = Fn(([x]: [Float]): Float => {
+        const i = x.floor().toVar('i')
+        const f = x.fract().toVar('f')
+        return random(i).mix(random(i.add(1)), float(0).smoothstep(float(1), f))
+}).setLayout({
+        name: 'gnoise',
+        type: 'float',
+        inputs: [{ name: 'x', type: 'float' }],
+})
+
+export const gnoiseVec2 = Fn(([st]: [Vec2]): Float => {
+        const i = st.floor().toVar('i')
+        const f = st.fract().toVar('f')
+        const a = randomVec2(i).toVar('a')
+        const b = randomVec2(i.add(vec2(1, 0))).toVar('b')
+        const c = randomVec2(i.add(vec2(0, 1))).toVar('c')
+        const d = randomVec2(i.add(vec2(1, 1))).toVar('d')
+        const u = cubicVec2(f).toVar('u')
+        return a.mix(b, u.x).add(c.sub(a).mul(u.y).mul(float(1).sub(u.x)).add(d.sub(b).mul(u.x).mul(u.y)))
+}).setLayout({
+        name: 'gnoiseVec2',
+        type: 'float',
+        inputs: [{ name: 'st', type: 'vec2' }],
+})
+
+export const gnoiseVec3 = Fn(([p]: [Vec3]): Float => {
+        const i = p.floor().toVar('i')
+        const f = p.fract().toVar('f')
+        const u = quintic(f).toVar('u')
+        return float(-1).add(
+                float(2).mul(
+                        randomVec3(i.add(vec3(0, 0, 0)))
+                                .mix(randomVec3(i.add(vec3(1, 0, 0))), u.x)
+                                .mix(randomVec3(i.add(vec3(0, 1, 0))).mix(randomVec3(i.add(vec3(1, 1, 0))), u.x), u.y)
+                                .mix(
+                                        randomVec3(i.add(vec3(0, 0, 1)))
+                                                .mix(randomVec3(i.add(vec3(1, 0, 1))), u.x)
+                                                .mix(
+                                                        randomVec3(i.add(vec3(0, 1, 1))).mix(
+                                                                randomVec3(i.add(vec3(1, 1, 1))),
+                                                                u.x
+                                                        ),
+                                                        u.y
+                                                ),
+                                        u.z
+                                )
+                )
+        )
+}).setLayout({
+        name: 'gnoiseVec3',
+        type: 'float',
+        inputs: [{ name: 'p', type: 'vec3' }],
+})
+
+export const gnoiseVec3Tiled = Fn(([p, tileLength]: [Vec3, Float]): Float => {
+        const i = p.floor().toVar('i')
+        const f = p.fract().toVar('f')
+        const u = quintic(f).toVar('u')
+        return srandom3Vec3Tiled(i.add(vec3(0, 0, 0)), tileLength)
+                .dot(f.sub(vec3(0, 0, 0)))
+                .mix(srandom3Vec3Tiled(i.add(vec3(1, 0, 0)), tileLength).dot(f.sub(vec3(1, 0, 0))), u.x)
+                .mix(
+                        srandom3Vec3Tiled(i.add(vec3(0, 1, 0)), tileLength)
+                                .dot(f.sub(vec3(0, 1, 0)))
+                                .mix(
+                                        srandom3Vec3Tiled(i.add(vec3(1, 1, 0)), tileLength).dot(f.sub(vec3(1, 1, 0))),
+                                        u.x
+                                ),
+                        u.y
+                )
+                .mix(
+                        srandom3Vec3Tiled(i.add(vec3(0, 0, 1)), tileLength)
+                                .dot(f.sub(vec3(0, 0, 1)))
+                                .mix(srandom3Vec3Tiled(i.add(vec3(1, 0, 1)), tileLength).dot(f.sub(vec3(1, 0, 1))), u.x)
+                                .mix(
+                                        srandom3Vec3Tiled(i.add(vec3(0, 1, 1)), tileLength)
+                                                .dot(f.sub(vec3(0, 1, 1)))
+                                                .mix(
+                                                        srandom3Vec3Tiled(i.add(vec3(1, 1, 1)), tileLength).dot(
+                                                                f.sub(vec3(1, 1, 1))
+                                                        ),
+                                                        u.x
+                                                ),
+                                        u.y
+                                ),
+                        u.z
+                )
+}).setLayout({
+        name: 'gnoiseVec3Tiled',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'tileLength', type: 'float' },
+        ],
+})
+
+export const gnoise3 = Fn(([x]: [Vec3]): Vec3 => {
+        return vec3(
+                gnoiseVec3(x.add(vec3(123.456, 0.567, 0.37))),
+                gnoiseVec3(x.add(vec3(0.11, 47.43, 19.17))),
+                gnoiseVec3(x)
+        )
+}).setLayout({
+        name: 'gnoise3',
+        type: 'vec3',
+        inputs: [{ name: 'x', type: 'vec3' }],
+})

package/src/addons/generative/index.ts

@@ -0,0 +1,15 @@
+export * from './cnoise'
+export * from './curl'
+export * from './fbm'
+export * from './gerstnerWave'
+export * from './gnoise'
+export * from './noised'
+export * from './pnoise'
+export * from './psrdnoise'
+export * from './random'
+export * from './snoise'
+export * from './srandom'
+export * from './voronoi'
+export * from './voronoise'
+export * from './wavelet'
+export * from './worley'

package/src/addons/generative/noised.ts

@@ -0,0 +1,139 @@
+import { Fn, Vec2, Vec3, vec2, vec3, vec4 } from '../../node'
+import { srandom2Vec2, srandom3Vec3 } from './srandom'
+
+export const noised = Fn(([p]: [Vec2]) => {
+        const i = p.floor().toVar('i')
+        const f = p.fract().toVar('f')
+        const u = f
+                .mul(f)
+                .mul(f)
+                .mul(f.mul(f.mul(6).sub(15)).add(10))
+                .toVar('u')
+        const du = f
+                .mul(f)
+                .mul(f.mul(f.sub(2)).add(1))
+                .mul(30)
+                .toVar('du')
+
+        const ga = srandom2Vec2(i.add(vec2(0, 0))).toVar('ga')
+        const gb = srandom2Vec2(i.add(vec2(1, 0))).toVar('gb')
+        const gc = srandom2Vec2(i.add(vec2(0, 1))).toVar('gc')
+        const gd = srandom2Vec2(i.add(vec2(1, 1))).toVar('gd')
+
+        const va = f.sub(vec2(0, 0)).dot(ga).toVar('va')
+        const vb = f.sub(vec2(1, 0)).dot(gb).toVar('vb')
+        const vc = f.sub(vec2(0, 1)).dot(gc).toVar('vc')
+        const vd = f.sub(vec2(1, 1)).dot(gd).toVar('vd')
+
+        return vec3(
+                va
+                        .add(u.x.mul(vb.sub(va)))
+                        .add(u.y.mul(vc.sub(va)))
+                        .add(u.x.mul(u.y).mul(va.sub(vb).sub(vc).add(vd))),
+                ga
+                        .add(u.x.mul(gb.sub(ga)))
+                        .add(u.y.mul(gc.sub(ga)))
+                        .add(u.x.mul(u.y).mul(ga.sub(gb).sub(gc).add(gd)))
+                        .add(du.mul(u.yx.mul(va.sub(vb).sub(vc).add(vd)).add(vec2(vb, vc)).sub(va)))
+        )
+}).setLayout({
+        name: 'noised',
+        type: 'vec3',
+        inputs: [{ name: 'p', type: 'vec2' }],
+})
+
+export const noisedVec3 = Fn(([pos]: [Vec3]) => {
+        const p = pos.floor().toVar('p')
+        const w = pos.fract().toVar('w')
+        const u = w
+                .mul(w)
+                .mul(w)
+                .mul(w.mul(w.mul(6).sub(15)).add(10))
+                .toVar('u')
+        const du = w
+                .mul(w)
+                .mul(w.mul(w.sub(2)).add(1))
+                .mul(30)
+                .toVar('du')
+
+        const ga = srandom3Vec3(p.add(vec3(0, 0, 0))).toVar('ga')
+        const gb = srandom3Vec3(p.add(vec3(1, 0, 0))).toVar('gb')
+        const gc = srandom3Vec3(p.add(vec3(0, 1, 0))).toVar('gc')
+        const gd = srandom3Vec3(p.add(vec3(1, 1, 0))).toVar('gd')
+        const ge = srandom3Vec3(p.add(vec3(0, 0, 1))).toVar('ge')
+        const gf = srandom3Vec3(p.add(vec3(1, 0, 1))).toVar('gf')
+        const gg = srandom3Vec3(p.add(vec3(0, 1, 1))).toVar('gg')
+        const gh = srandom3Vec3(p.add(vec3(1, 1, 1))).toVar('gh')
+
+        const va = w.sub(vec3(0, 0, 0)).dot(ga).toVar('va')
+        const vb = w.sub(vec3(1, 0, 0)).dot(gb).toVar('vb')
+        const vc = w.sub(vec3(0, 1, 0)).dot(gc).toVar('vc')
+        const vd = w.sub(vec3(1, 1, 0)).dot(gd).toVar('vd')
+        const ve = w.sub(vec3(0, 0, 1)).dot(ge).toVar('ve')
+        const vf = w.sub(vec3(1, 0, 1)).dot(gf).toVar('vf')
+        const vg = w.sub(vec3(0, 1, 1)).dot(gg).toVar('vg')
+        const vh = w.sub(vec3(1, 1, 1)).dot(gh).toVar('vh')
+
+        const noiseValue = va
+                .add(u.x.mul(vb.sub(va)))
+                .add(u.y.mul(vc.sub(va)))
+                .add(u.z.mul(ve.sub(va)))
+                .add(u.x.mul(u.y).mul(va.sub(vb).sub(vc).add(vd)))
+                .add(u.y.mul(u.z).mul(va.sub(vc).sub(ve).add(vg)))
+                .add(u.z.mul(u.x).mul(va.sub(vb).sub(ve).add(vf)))
+                .add(va.negate().add(vb).add(vc).sub(vd).add(ve).sub(vf).sub(vg).add(vh).mul(u.x).mul(u.y).mul(u.z))
+
+        const gradientValue = ga
+                .add(u.x.mul(gb.sub(ga)))
+                .add(u.y.mul(gc.sub(ga)))
+                .add(u.z.mul(ge.sub(ga)))
+                .add(u.x.mul(u.y).mul(ga.sub(gb).sub(gc).add(gd)))
+                .add(u.y.mul(u.z).mul(ga.sub(gc).sub(ge).add(gg)))
+                .add(u.z.mul(u.x).mul(ga.sub(gb).sub(ge).add(gf)))
+                .add(ga.negate().add(gb).add(gc).sub(gd).add(ge).sub(gf).sub(gg).add(gh).mul(u.x).mul(u.y).mul(u.z))
+                .add(
+                        du.mul(
+                                vec3(vb, vc, ve)
+                                        .sub(va)
+                                        .add(
+                                                u.yzx.mul(
+                                                        vec3(
+                                                                va.sub(vb).sub(vc).add(vd),
+                                                                va.sub(vc).sub(ve).add(vg),
+                                                                va.sub(vb).sub(ve).add(vf)
+                                                        )
+                                                )
+                                        )
+                                        .add(
+                                                u.zxy.mul(
+                                                        vec3(
+                                                                va.sub(vb).sub(ve).add(vf),
+                                                                va.sub(vb).sub(vc).add(vd),
+                                                                va.sub(vc).sub(ve).add(vg)
+                                                        )
+                                                )
+                                        )
+                                        .add(
+                                                u.yzx
+                                                        .mul(u.zxy)
+                                                        .mul(
+                                                                va
+                                                                        .negate()
+                                                                        .add(vb)
+                                                                        .add(vc)
+                                                                        .sub(vd)
+                                                                        .add(ve)
+                                                                        .sub(vf)
+                                                                        .sub(vg)
+                                                                        .add(vh)
+                                                        )
+                                        )
+                        )
+                )
+
+        return vec4(noiseValue, gradientValue)
+}).setLayout({
+        name: 'noisedVec3',
+        type: 'vec4',
+        inputs: [{ name: 'pos', type: 'vec3' }],
+})

package/src/addons/generative/pnoise.ts

@@ -0,0 +1,249 @@
+import { Fn, Vec2, Vec3, Vec4, vec2, vec3, vec4, mix, step } from '../../node'
+import { mod289Vec4, mod289Vec3 } from '../math/mod289'
+import { permuteVec4 } from '../math/permute'
+import { taylorInvSqrt } from '../math/taylorInvSqrt'
+import { quintic } from '../math/quintic'
+
+export const pnoise = Fn(([P, rep]: [Vec2, Vec2]) => {
+        const Pi = P.xyxy.floor().add(vec4(0, 0, 1, 1)).toVar('Pi')
+        const Pf = P.xyxy.fract().sub(vec4(0, 0, 1, 1)).toVar('Pf')
+        Pi.assign(Pi.mod(rep.xyxy))
+        Pi.assign(mod289Vec4(Pi))
+        const ix = Pi.xzxz.toVar('ix')
+        const iy = Pi.yyww.toVar('iy')
+        const fx = Pf.xzxz.toVar('fx')
+        const fy = Pf.yyww.toVar('fy')
+        const i = permuteVec4(permuteVec4(ix).add(iy)).toVar('i')
+        const gx = i.div(41).fract().mul(2).sub(1).toVar('gx')
+        const gy = gx.abs().sub(0.5).toVar('gy')
+        const tx = gx.add(0.5).floor().toVar('tx')
+        gx.assign(gx.sub(tx))
+        const g00 = vec2(gx.x, gy.x).toVar('g00')
+        const g10 = vec2(gx.y, gy.y).toVar('g10')
+        const g01 = vec2(gx.z, gy.z).toVar('g01')
+        const g11 = vec2(gx.w, gy.w).toVar('g11')
+        const norm = taylorInvSqrt(vec4(g00.dot(g00), g01.dot(g01), g10.dot(g10), g11.dot(g11))).toVar('norm')
+        g00.mulAssign(norm.x)
+        g01.mulAssign(norm.y)
+        g10.mulAssign(norm.z)
+        g11.mulAssign(norm.w)
+        const n00 = g00.dot(vec2(fx.x, fy.x)).toVar('n00')
+        const n10 = g10.dot(vec2(fx.y, fy.y)).toVar('n10')
+        const n01 = g01.dot(vec2(fx.z, fy.z)).toVar('n01')
+        const n11 = g11.dot(vec2(fx.w, fy.w)).toVar('n11')
+        const fade_xy = quintic(Pf.xy).toVar('fade_xy')
+        const n_x = vec2(n00, n01).mix(vec2(n10, n11), fade_xy.x).toVar('n_x')
+        const n_xy = n_x.x.mix(n_x.y, fade_xy.y).toVar('n_xy')
+        return n_xy.mul(2.3)
+}).setLayout({
+        name: 'pnoise',
+        type: 'float',
+        inputs: [
+                { name: 'P', type: 'vec2' },
+                { name: 'rep', type: 'vec2' },
+        ],
+})
+
+export const pnoiseVec3 = Fn(([P, rep]: [Vec3, Vec3]) => {
+        const Pi0 = P.floor().mod(rep).toVar('Pi0')
+        const Pi1 = Pi0.add(vec3(1)).mod(rep).toVar('Pi1')
+        Pi0.assign(mod289Vec3(Pi0))
+        Pi1.assign(mod289Vec3(Pi1))
+        const Pf0 = P.fract().toVar('Pf0')
+        const Pf1 = Pf0.sub(vec3(1)).toVar('Pf1')
+        const ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x).toVar('ix')
+        const iy = vec4(Pi0.yy, Pi1.yy).toVar('iy')
+        const iz0 = Pi0.zzzz.toVar('iz0')
+        const iz1 = Pi1.zzzz.toVar('iz1')
+        const ixy = permuteVec4(permuteVec4(ix).add(iy)).toVar('ixy')
+        const ixy0 = permuteVec4(ixy.add(iz0)).toVar('ixy0')
+        const ixy1 = permuteVec4(ixy.add(iz1)).toVar('ixy1')
+        const gx0 = ixy0.div(7).toVar('gx0')
+        const gy0 = gx0.floor().div(7).fract().sub(0.5).toVar('gy0')
+        gx0.assign(gx0.fract())
+        const gz0 = vec4(0.5).sub(gx0.abs()).sub(gy0.abs()).toVar('gz0')
+        const sz0 = gz0.step(vec4(0)).toVar('sz0')
+        gx0.subAssign(sz0.mul(gx0.step(vec4(0)).sub(0.5)))
+        gy0.subAssign(sz0.mul(gy0.step(vec4(0)).sub(0.5)))
+        const gx1 = ixy1.div(7).toVar('gx1')
+        const gy1 = gx1.floor().div(7).fract().sub(0.5).toVar('gy1')
+        gx1.assign(gx1.fract())
+        const gz1 = vec4(0.5).sub(gx1.abs()).sub(gy1.abs()).toVar('gz1')
+        const sz1 = gz1.step(vec4(0)).toVar('sz1')
+        gx1.subAssign(sz1.mul(gx1.step(vec4(0)).sub(0.5)))
+        gy1.subAssign(sz1.mul(gy1.step(vec4(0)).sub(0.5)))
+        const g000 = vec3(gx0.x, gy0.x, gz0.x).toVar('g000')
+        const g100 = vec3(gx0.y, gy0.y, gz0.y).toVar('g100')
+        const g010 = vec3(gx0.z, gy0.z, gz0.z).toVar('g010')
+        const g110 = vec3(gx0.w, gy0.w, gz0.w).toVar('g110')
+        const g001 = vec3(gx1.x, gy1.x, gz1.x).toVar('g001')
+        const g101 = vec3(gx1.y, gy1.y, gz1.y).toVar('g101')
+        const g011 = vec3(gx1.z, gy1.z, gz1.z).toVar('g011')
+        const g111 = vec3(gx1.w, gy1.w, gz1.w).toVar('g111')
+        const norm0 = taylorInvSqrt(vec4(g000.dot(g000), g010.dot(g010), g100.dot(g100), g110.dot(g110))).toVar('norm0')
+        g000.mulAssign(norm0.x)
+        g010.mulAssign(norm0.y)
+        g100.mulAssign(norm0.z)
+        g110.mulAssign(norm0.w)
+        const norm1 = taylorInvSqrt(vec4(g001.dot(g001), g011.dot(g011), g101.dot(g101), g111.dot(g111))).toVar('norm1')
+        g001.mulAssign(norm1.x)
+        g011.mulAssign(norm1.y)
+        g101.mulAssign(norm1.z)
+        g111.mulAssign(norm1.w)
+        const n000 = g000.dot(Pf0).toVar('n000')
+        const n100 = g100.dot(vec3(Pf1.x, Pf0.yz)).toVar('n100')
+        const n010 = g010.dot(vec3(Pf0.x, Pf1.y, Pf0.z)).toVar('n010')
+        const n110 = g110.dot(vec3(Pf1.xy, Pf0.z)).toVar('n110')
+        const n001 = g001.dot(vec3(Pf0.xy, Pf1.z)).toVar('n001')
+        const n101 = g101.dot(vec3(Pf1.x, Pf0.y, Pf1.z)).toVar('n101')
+        const n011 = g011.dot(vec3(Pf0.x, Pf1.yz)).toVar('n011')
+        const n111 = g111.dot(Pf1).toVar('n111')
+        const fade_xyz = quintic(Pf0).toVar('fade_xyz')
+        const n_z = vec4(n000, n100, n010, n110).mix(vec4(n001, n101, n011, n111), fade_xyz.z).toVar('n_z')
+        const n_yz = n_z.xy.mix(n_z.zw, fade_xyz.y).toVar('n_yz')
+        const n_xyz = n_yz.x.mix(n_yz.y, fade_xyz.x).toVar('n_xyz')
+        return n_xyz.mul(2.2)
+}).setLayout({
+        name: 'pnoiseVec3',
+        type: 'float',
+        inputs: [
+                { name: 'P', type: 'vec3' },
+                { name: 'rep', type: 'vec3' },
+        ],
+})
+
+export const pnoiseVec4 = Fn(([P, rep]: [Vec4, Vec4]) => {
+        const Pi0 = P.floor().mod(rep).toVar('Pi0')
+        const Pi1 = Pi0.add(1).mod(rep).toVar('Pi1')
+        Pi0.assign(mod289Vec4(Pi0))
+        Pi1.assign(mod289Vec4(Pi1))
+        const Pf0 = P.fract().toVar('Pf0')
+        const Pf1 = Pf0.sub(1).toVar('Pf1')
+        const ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x).toVar('ix')
+        const iy = vec4(Pi0.yy, Pi1.yy).toVar('iy')
+        const iz0 = vec4(Pi0.zzzz).toVar('iz0')
+        const iz1 = vec4(Pi1.zzzz).toVar('iz1')
+        const iw0 = vec4(Pi0.wwww).toVar('iw0')
+        const iw1 = vec4(Pi1.wwww).toVar('iw1')
+        const ixy = permuteVec4(permuteVec4(ix).add(iy)).toVar('ixy')
+        const ixy0 = permuteVec4(ixy.add(iz0)).toVar('ixy0')
+        const ixy1 = permuteVec4(ixy.add(iz1)).toVar('ixy1')
+        const ixy00 = permuteVec4(ixy0.add(iw0)).toVar('ixy00')
+        const ixy01 = permuteVec4(ixy0.add(iw1)).toVar('ixy01')
+        const ixy10 = permuteVec4(ixy1.add(iw0)).toVar('ixy10')
+        const ixy11 = permuteVec4(ixy1.add(iw1)).toVar('ixy11')
+        const gx00 = ixy00.div(7).toVar('gx00')
+        const gy00 = gx00.floor().div(7).toVar('gy00')
+        const gz00 = gy00.floor().div(6).toVar('gz00')
+        gx00.assign(gx00.fract().sub(0.5))
+        gy00.assign(gy00.fract().sub(0.5))
+        gz00.assign(gz00.fract().sub(0.5))
+        const gw00 = vec4(0.75).sub(gx00.abs()).sub(gy00.abs()).sub(gz00.abs()).toVar('gw00')
+        const sw00 = gw00.step(vec4(0)).toVar('sw00')
+        gx00.subAssign(sw00.mul(vec4(0).step(gx00).sub(0.5)))
+        gy00.subAssign(sw00.mul(vec4(0).step(gy00).sub(0.5)))
+        const gx01 = ixy01.div(7).toVar('gx01')
+        const gy01 = gx01.floor().div(7).toVar('gy01')
+        const gz01 = gy01.floor().div(6).toVar('gz01')
+        gx01.assign(gx01.fract().sub(0.5))
+        gy01.assign(gy01.fract().sub(0.5))
+        gz01.assign(gz01.fract().sub(0.5))
+        const gw01 = vec4(0.75).sub(gx01.abs()).sub(gy01.abs()).sub(gz01.abs()).toVar('gw01')
+        const sw01 = gw01.step(vec4(0)).toVar('sw01')
+        gx01.subAssign(sw01.mul(vec4(0).step(gx01).sub(0.5)))
+        gy01.subAssign(sw01.mul(vec4(0).step(gy01).sub(0.5)))
+        const gx10 = ixy10.div(7).toVar('gx10')
+        const gy10 = gx10.floor().div(7).toVar('gy10')
+        const gz10 = gy10.floor().div(6).toVar('gz10')
+        gx10.assign(gx10.fract().sub(0.5))
+        gy10.assign(gy10.fract().sub(0.5))
+        gz10.assign(gz10.fract().sub(0.5))
+        const gw10 = vec4(0.75).sub(gx10.abs()).sub(gy10.abs()).sub(gz10.abs()).toVar('gw10')
+        const sw10 = gw10.step(vec4(0)).toVar('sw10')
+        gx10.subAssign(sw10.mul(vec4(0).step(gx10).sub(0.5)))
+        gy10.subAssign(sw10.mul(vec4(0).step(gy10).sub(0.5)))
+        const gx11 = ixy11.div(7).toVar('gx11')
+        const gy11 = gx11.floor().div(7).toVar('gy11')
+        const gz11 = gy11.floor().div(6).toVar('gz11')
+        gx11.assign(gx11.fract().sub(0.5))
+        gy11.assign(gy11.fract().sub(0.5))
+        gz11.assign(gz11.fract().sub(0.5))
+        const gw11 = vec4(0.75).sub(gx11.abs()).sub(gy11.abs()).sub(gz11.abs()).toVar('gw11')
+        const sw11 = gw11.step(vec4(0)).toVar('sw11')
+        gx11.subAssign(sw11.mul(vec4(0).step(gx11).sub(0.5)))
+        gy11.subAssign(sw11.mul(vec4(0).step(gy11).sub(0.5)))
+        const g0000 = vec4(gx00.x, gy00.x, gz00.x, gw00.x).toVar('g0000')
+        const g1000 = vec4(gx00.y, gy00.y, gz00.y, gw00.y).toVar('g1000')
+        const g0100 = vec4(gx00.z, gy00.z, gz00.z, gw00.z).toVar('g0100')
+        const g1100 = vec4(gx00.w, gy00.w, gz00.w, gw00.w).toVar('g1100')
+        const g0010 = vec4(gx10.x, gy10.x, gz10.x, gw10.x).toVar('g0010')
+        const g1010 = vec4(gx10.y, gy10.y, gz10.y, gw10.y).toVar('g1010')
+        const g0110 = vec4(gx10.z, gy10.z, gz10.z, gw10.z).toVar('g0110')
+        const g1110 = vec4(gx10.w, gy10.w, gz10.w, gw10.w).toVar('g1110')
+        const g0001 = vec4(gx01.x, gy01.x, gz01.x, gw01.x).toVar('g0001')
+        const g1001 = vec4(gx01.y, gy01.y, gz01.y, gw01.y).toVar('g1001')
+        const g0101 = vec4(gx01.z, gy01.z, gz01.z, gw01.z).toVar('g0101')
+        const g1101 = vec4(gx01.w, gy01.w, gz01.w, gw01.w).toVar('g1101')
+        const g0011 = vec4(gx11.x, gy11.x, gz11.x, gw11.x).toVar('g0011')
+        const g1011 = vec4(gx11.y, gy11.y, gz11.y, gw11.y).toVar('g1011')
+        const g0111 = vec4(gx11.z, gy11.z, gz11.z, gw11.z).toVar('g0111')
+        const g1111 = vec4(gx11.w, gy11.w, gz11.w, gw11.w).toVar('g1111')
+        const norm00 = taylorInvSqrt(
+                vec4(g0000.dot(g0000), g0100.dot(g0100), g1000.dot(g1000), g1100.dot(g1100))
+        ).toVar('norm00')
+        g0000.mulAssign(norm00.x)
+        g0100.mulAssign(norm00.y)
+        g1000.mulAssign(norm00.z)
+        g1100.mulAssign(norm00.w)
+        const norm01 = taylorInvSqrt(
+                vec4(g0001.dot(g0001), g0101.dot(g0101), g1001.dot(g1001), g1101.dot(g1101))
+        ).toVar('norm01')
+        g0001.mulAssign(norm01.x)
+        g0101.mulAssign(norm01.y)
+        g1001.mulAssign(norm01.z)
+        g1101.mulAssign(norm01.w)
+        const norm10 = taylorInvSqrt(
+                vec4(g0010.dot(g0010), g0110.dot(g0110), g1010.dot(g1010), g1110.dot(g1110))
+        ).toVar('norm10')
+        g0010.mulAssign(norm10.x)
+        g0110.mulAssign(norm10.y)
+        g1010.mulAssign(norm10.z)
+        g1110.mulAssign(norm10.w)
+        const norm11 = taylorInvSqrt(
+                vec4(g0011.dot(g0011), g0111.dot(g0111), g1011.dot(g1011), g1111.dot(g1111))
+        ).toVar('norm11')
+        g0011.mulAssign(norm11.x)
+        g0111.mulAssign(norm11.y)
+        g1011.mulAssign(norm11.z)
+        g1111.mulAssign(norm11.w)
+        const n0000 = g0000.dot(Pf0).toVar('n0000')
+        const n1000 = g1000.dot(vec4(Pf1.x, Pf0.yzw)).toVar('n1000')
+        const n0100 = g0100.dot(vec4(Pf0.x, Pf1.y, Pf0.zw)).toVar('n0100')
+        const n1100 = g1100.dot(vec4(Pf1.xy, Pf0.zw)).toVar('n1100')
+        const n0010 = g0010.dot(vec4(Pf0.xy, Pf1.z, Pf0.w)).toVar('n0010')
+        const n1010 = g1010.dot(vec4(Pf1.x, Pf0.y, Pf1.z, Pf0.w)).toVar('n1010')
+        const n0110 = g0110.dot(vec4(Pf0.x, Pf1.yz, Pf0.w)).toVar('n0110')
+        const n1110 = g1110.dot(vec4(Pf1.xyz, Pf0.w)).toVar('n1110')
+        const n0001 = g0001.dot(vec4(Pf0.xyz, Pf1.w)).toVar('n0001')
+        const n1001 = g1001.dot(vec4(Pf1.x, Pf0.yz, Pf1.w)).toVar('n1001')
+        const n0101 = g0101.dot(vec4(Pf0.x, Pf1.y, Pf0.z, Pf1.w)).toVar('n0101')
+        const n1101 = g1101.dot(vec4(Pf1.xy, Pf0.z, Pf1.w)).toVar('n1101')
+        const n0011 = g0011.dot(vec4(Pf0.xy, Pf1.zw)).toVar('n0011')
+        const n1011 = g1011.dot(vec4(Pf1.x, Pf0.y, Pf1.zw)).toVar('n1011')
+        const n0111 = g0111.dot(vec4(Pf0.x, Pf1.yzw)).toVar('n0111')
+        const n1111 = g1111.dot(Pf1).toVar('n1111')
+        const fade_xyzw = quintic(Pf0).toVar('fade_xyzw')
+        const n_0w = vec4(n0000, n1000, n0100, n1100).mix(vec4(n0001, n1001, n0101, n1101), fade_xyzw.w).toVar('n_0w')
+        const n_1w = vec4(n0010, n1010, n0110, n1110).mix(vec4(n0011, n1011, n0111, n1111), fade_xyzw.w).toVar('n_1w')
+        const n_zw = n_0w.mix(n_1w, fade_xyzw.z).toVar('n_zw')
+        const n_yzw = n_zw.xy.mix(n_zw.zw, fade_xyzw.y).toVar('n_yzw')
+        const n_xyzw = n_yzw.x.mix(n_yzw.y, fade_xyzw.x).toVar('n_xyzw')
+        return n_xyzw.mul(2.2)
+}).setLayout({
+        name: 'pnoiseVec4',
+        type: 'float',
+        inputs: [
+                { name: 'P', type: 'vec4' },
+                { name: 'rep', type: 'vec4' },
+        ],
+})