glre 0.38.0 → 0.40.0

package/src/addons/generative/curl.ts

@@ -0,0 +1,64 @@
+import { Fn, Vec2, Vec3, Vec4, vec2, vec3, vec4, float } from '../../node'
+import { snoise2, snoise3Vec3, snoise3Vec4 } from './snoise'
+
+export const curlVec2 = Fn(([p]: [Vec2]): Vec2 => {
+        const e = float(0.1).toVar('e')
+        const dx = vec2(e, 0).toVar('dx')
+        const dy = vec2(0, e).toVar('dy')
+        const p_x0 = snoise2(p.sub(dx)).toVar('p_x0')
+        const p_x1 = snoise2(p.add(dx)).toVar('p_x1')
+        const p_y0 = snoise2(p.sub(dy)).toVar('p_y0')
+        const p_y1 = snoise2(p.add(dy)).toVar('p_y1')
+        const x = p_x1.y.add(p_x0.y).toVar('x')
+        const y = p_y1.x.sub(p_y0.x).toVar('y')
+        const divisor = float(1).div(e.mul(2)).toVar('divisor')
+        return vec2(x, y).mul(divisor).normalize()
+}).setLayout({
+        name: 'curlVec2',
+        type: 'vec2',
+        inputs: [{ name: 'p', type: 'vec2' }],
+})
+
+export const curlVec3 = Fn(([p]: [Vec3]): Vec3 => {
+        const e = float(0.1).toVar('e')
+        const dx = vec3(e, 0, 0).toVar('dx')
+        const dy = vec3(0, e, 0).toVar('dy')
+        const dz = vec3(0, 0, e).toVar('dz')
+        const p_x0 = snoise3Vec3(p.sub(dx)).toVar('p_x0')
+        const p_x1 = snoise3Vec3(p.add(dx)).toVar('p_x1')
+        const p_y0 = snoise3Vec3(p.sub(dy)).toVar('p_y0')
+        const p_y1 = snoise3Vec3(p.add(dy)).toVar('p_y1')
+        const p_z0 = snoise3Vec3(p.sub(dz)).toVar('p_z0')
+        const p_z1 = snoise3Vec3(p.add(dz)).toVar('p_z1')
+        const x = p_y1.z.sub(p_y0.z).sub(p_z1.y).add(p_z0.y).toVar('x')
+        const y = p_z1.x.sub(p_z0.x).sub(p_x1.z).add(p_x0.z).toVar('y')
+        const z = p_x1.y.sub(p_x0.y).sub(p_y1.x).add(p_y0.x).toVar('z')
+        const divisor = float(1).div(e.mul(2)).toVar('divisor')
+        return vec3(x, y, z).mul(divisor).normalize()
+}).setLayout({
+        name: 'curlVec3',
+        type: 'vec3',
+        inputs: [{ name: 'p', type: 'vec3' }],
+})
+
+export const curlVec4 = Fn(([p]: [Vec4]): Vec3 => {
+        const e = float(0.1).toVar('e')
+        const dx = vec4(e, 0, 0, 1).toVar('dx')
+        const dy = vec4(0, e, 0, 1).toVar('dy')
+        const dz = vec4(0, 0, e, 1).toVar('dz')
+        const p_x0 = snoise3Vec4(p.sub(dx)).toVar('p_x0')
+        const p_x1 = snoise3Vec4(p.add(dx)).toVar('p_x1')
+        const p_y0 = snoise3Vec4(p.sub(dy)).toVar('p_y0')
+        const p_y1 = snoise3Vec4(p.add(dy)).toVar('p_y1')
+        const p_z0 = snoise3Vec4(p.sub(dz)).toVar('p_z0')
+        const p_z1 = snoise3Vec4(p.add(dz)).toVar('p_z1')
+        const x = p_y1.z.sub(p_y0.z).sub(p_z1.y).add(p_z0.y).toVar('x')
+        const y = p_z1.x.sub(p_z0.x).sub(p_x1.z).add(p_x0.z).toVar('y')
+        const z = p_x1.y.sub(p_x0.y).sub(p_y1.x).add(p_y0.x).toVar('z')
+        const divisor = float(1).div(e.mul(2)).toVar('divisor')
+        return vec3(x, y, z).mul(divisor).normalize()
+}).setLayout({
+        name: 'curlVec4',
+        type: 'vec3',
+        inputs: [{ name: 'p', type: 'vec4' }],
+})

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