glre 0.38.0 → 0.40.0

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

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