glre 0.38.0 → 0.40.0

package/src/addons/draw/bridge.ts

@@ -0,0 +1,81 @@
+import { Fn, Float, Vec2, Vec3, Vec4, X, float } from '../../node'
+import { stroke } from './stroke'
+
+// Bridge effect for float
+export const bridgeFloat = Fn(([c, d, s, w]: [Float, Float, Float, Float]): Float => {
+        const maskedC = c.mul(float(1).sub(stroke(d, s, w.mul(2))))
+        return maskedC.add(stroke(d, s, w))
+}).setLayout({
+        name: 'bridgeFloat',
+        type: 'float',
+        inputs: [
+                { name: 'c', type: 'float' },
+                { name: 'd', type: 'float' },
+                { name: 's', type: 'float' },
+                { name: 'w', type: 'float' },
+        ],
+})
+
+// Bridge effect for vec2
+export const bridgeVec2 = Fn(([c, d, s, w]: [Vec2, Float, Float, Float]): Vec2 => {
+        const strokeMask = stroke(d, s, w.mul(2))
+        const maskedC = c.mul(float(1).sub(strokeMask))
+        return maskedC.add(strokeMask)
+}).setLayout({
+        name: 'bridgeVec2',
+        type: 'vec2',
+        inputs: [
+                { name: 'c', type: 'vec2' },
+                { name: 'd', type: 'float' },
+                { name: 's', type: 'float' },
+                { name: 'w', type: 'float' },
+        ],
+})
+
+// Bridge effect for vec3
+export const bridgeVec3 = Fn(([c, d, s, w]: [Vec3, Float, Float, Float]): Vec3 => {
+        const strokeMask = stroke(d, s, w.mul(2))
+        const maskedC = c.mul(float(1).sub(strokeMask))
+        return maskedC.add(strokeMask)
+}).setLayout({
+        name: 'bridgeVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'c', type: 'vec3' },
+                { name: 'd', type: 'float' },
+                { name: 's', type: 'float' },
+                { name: 'w', type: 'float' },
+        ],
+})
+
+// Bridge effect for vec4
+export const bridgeVec4 = Fn(([c, d, s, w]: [Vec4, Float, Float, Float]): Vec4 => {
+        const strokeMask = stroke(d, s, w.mul(2))
+        const maskedC = c.mul(float(1).sub(strokeMask))
+        return maskedC.add(strokeMask)
+}).setLayout({
+        name: 'bridgeVec4',
+        type: 'vec4',
+        inputs: [
+                { name: 'c', type: 'vec4' },
+                { name: 'd', type: 'float' },
+                { name: 's', type: 'float' },
+                { name: 'w', type: 'float' },
+        ],
+})
+
+// Generic bridge function using auto type
+export const bridge = Fn(([c, d, s, w]: [X, Float, Float, Float]): X => {
+        const strokeMask = stroke(d, s, (w as any).mul(2))
+        const maskedC = (c as any).mul(float(1).sub(strokeMask))
+        return maskedC.add(strokeMask)
+}).setLayout({
+        name: 'bridge',
+        type: 'auto',
+        inputs: [
+                { name: 'c', type: 'auto' },
+                { name: 'd', type: 'float' },
+                { name: 's', type: 'float' },
+                { name: 'w', type: 'float' },
+        ],
+})

package/src/addons/draw/char.ts

@@ -0,0 +1,30 @@
+import { Fn, Vec2, Int, Float, float, vec2, floor, ivec2 } from '../../node'
+
+export const charLookupSimple = Fn(([index]: [Int]): Float => {
+        const isValidChar = index.greaterThan(31).and(index.lessThan(127))
+        return float(0).select(float(1), isValidChar)
+}).setLayout({
+        name: 'charLookupSimple',
+        type: 'float',
+        inputs: [{ name: 'index', type: 'int' }],
+})
+
+export const charSimple = Fn(([uv, charCode]: [Vec2, Int]): Float => {
+        const charCoord = ivec2(floor(uv.mul(vec2(8, 16)))).toVar()
+        charCoord.x.assign(charCoord.x.clamp(0, 7))
+        charCoord.y.assign(charCoord.y.clamp(0, 15))
+        const centerX = charCoord.x.sub(4).abs()
+        const centerY = charCoord.y.sub(8).abs()
+        const pattern = centerX.add(centerY).lessThan(charCode.mod(8) as any)
+        return float(0).select(float(1), pattern)
+}).setLayout({
+        name: 'charSimple',
+        type: 'float',
+        inputs: [
+                { name: 'uv', type: 'vec2' },
+                { name: 'charCode', type: 'int' },
+        ],
+})
+
+// Default char function using simplified implementation
+export const char = charSimple

package/src/addons/draw/circle.ts

@@ -0,0 +1,29 @@
+import { Fn, Vec2, Float } from '../../node'
+import { circleSDFBasic } from '../sdf/circleSDF'
+import { fill } from './fill'
+import { stroke } from './stroke'
+
+export const circleFill = Fn(([st, size]: [Vec2, Float]): Float => {
+        return fill(circleSDFBasic(st), size)
+}).setLayout({
+        name: 'circleFill',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'size', type: 'float' },
+        ],
+})
+
+export const circleStroke = Fn(([st, size, strokeWidth]: [Vec2, Float, Float]): Float => {
+        return stroke(circleSDFBasic(st), size, strokeWidth)
+}).setLayout({
+        name: 'circleStroke',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'size', type: 'float' },
+                { name: 'strokeWidth', type: 'float' },
+        ],
+})
+
+export const circle = circleFill

package/src/addons/draw/fill.ts

@@ -0,0 +1,25 @@
+import { Fn, Float, smoothstep } from '../../node'
+import { aastep } from '../math/aastep'
+
+export const fillWithEdge = Fn(([x, size, edge]: [Float, Float, Float]): Float => {
+        return smoothstep(size.sub(edge), size.add(edge), x).oneMinus()
+}).setLayout({
+        name: 'fillWithEdge',
+        type: 'float',
+        inputs: [
+                { name: 'x', type: 'float' },
+                { name: 'size', type: 'float' },
+                { name: 'edge', type: 'float' },
+        ],
+})
+
+export const fill = Fn(([x, size]: [Float, Float]): Float => {
+        return aastep(size, x).oneMinus()
+}).setLayout({
+        name: 'fill',
+        type: 'float',
+        inputs: [
+                { name: 'x', type: 'float' },
+                { name: 'size', type: 'float' },
+        ],
+})

package/src/addons/draw/flip.ts

@@ -0,0 +1,45 @@
+import { Fn, Float, Vec3, Vec4, X, float, vec3, vec4, mix } from '../../node'
+
+export const flipFloat = Fn(([v, pct]: [Float, Float]): Float => {
+        return mix(v, float(1).sub(v), pct)
+}).setLayout({
+        name: 'flipFloat',
+        type: 'float',
+        inputs: [
+                { name: 'v', type: 'float' },
+                { name: 'pct', type: 'float' },
+        ],
+})
+
+export const flipVec3 = Fn(([v, pct]: [Vec3, Float]): Vec3 => {
+        return mix(v, vec3(1).sub(v), pct)
+}).setLayout({
+        name: 'flipVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'v', type: 'vec3' },
+                { name: 'pct', type: 'float' },
+        ],
+})
+
+export const flipVec4 = Fn(([v, pct]: [Vec4, Float]): Vec4 => {
+        return mix(v, vec4(1).sub(v), pct)
+}).setLayout({
+        name: 'flipVec4',
+        type: 'vec4',
+        inputs: [
+                { name: 'v', type: 'vec4' },
+                { name: 'pct', type: 'float' },
+        ],
+})
+
+export const flip = Fn(([v, pct]: [X, Float]): X => {
+        return mix(v, v.oneMinus(), pct)
+}).setLayout({
+        name: 'flip',
+        type: 'auto',
+        inputs: [
+                { name: 'v', type: 'auto' },
+                { name: 'pct', type: 'float' },
+        ],
+})

package/src/addons/draw/hex.ts

@@ -0,0 +1,29 @@
+import { Fn, Vec2, Float } from '../../node'
+import { hexSDF } from '../sdf/hexSDF'
+import { fill } from './fill'
+import { stroke } from './stroke'
+
+export const hexFill = Fn(([st, size]: [Vec2, Float]): Float => {
+        return fill(hexSDF(st), size)
+}).setLayout({
+        name: 'hexFill',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'size', type: 'float' },
+        ],
+})
+
+export const hexStroke = Fn(([st, size, strokeWidth]: [Vec2, Float, Float]): Float => {
+        return stroke(hexSDF(st), size, strokeWidth)
+}).setLayout({
+        name: 'hexStroke',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'size', type: 'float' },
+                { name: 'strokeWidth', type: 'float' },
+        ],
+})
+
+export const hex = hexFill

package/src/addons/draw/index.ts

@@ -0,0 +1,13 @@
+export * from './arrows'
+export * from './axis'
+export * from './bridge'
+export * from './char'
+export * from './circle'
+export * from './fill'
+export * from './flip'
+export * from './hex'
+export * from './line'
+export * from './point'
+export * from './rect'
+export * from './stroke'
+export * from './tri'

package/src/addons/draw/line.ts

@@ -0,0 +1,16 @@
+import { Fn, Vec2, Float } from '../../node'
+import { lineSDF } from '../sdf/lineSDF'
+import { fill } from './fill'
+
+export const line = Fn(([st, a, b, thickness]: [Vec2, Vec2, Vec2, Float]): Float => {
+        return fill(lineSDF(st, a, b), thickness)
+}).setLayout({
+        name: 'line',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'a', type: 'vec2' },
+                { name: 'b', type: 'vec2' },
+                { name: 'thickness', type: 'float' },
+        ],
+})

package/src/addons/draw/point.ts

@@ -0,0 +1,30 @@
+import { Fn, Vec2, Vec3, Vec4, Float, vec3, vec4, float } from '../../node'
+import { circleFill } from './circle'
+
+export const point2D = Fn(([st, pos, color, radius]: [Vec2, Vec2, Vec3, Float]): Vec4 => {
+        const st_p = st.sub(pos)
+        const circle = circleFill(st_p.add(0.5), radius)
+        return vec4(color, 1).mul(circle)
+}).setLayout({
+        name: 'point2D',
+        type: 'vec4',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'pos', type: 'vec2' },
+                { name: 'color', type: 'vec3' },
+                { name: 'radius', type: 'float' },
+        ],
+})
+
+export const pointSimple = Fn(([st, pos]: [Vec2, Vec2]): Vec4 => {
+        return point2D(st, pos, vec3(1, 0, 0), float(0.02))
+}).setLayout({
+        name: 'pointSimple',
+        type: 'vec4',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'pos', type: 'vec2' },
+        ],
+})
+
+export const point = pointSimple

package/src/addons/draw/rect.ts

@@ -0,0 +1,52 @@
+import { Fn, Vec2, Float, float } from '../../node'
+import { rectSDF, rectSDFUniform } from '../sdf/rectSDF'
+import { fill } from './fill'
+import { stroke } from './stroke'
+
+export const rectStroke = Fn(([st, size, strokeWidth]: [Vec2, Vec2, Float]): Float => {
+        return stroke(rectSDF(st, size), float(1), strokeWidth)
+}).setLayout({
+        name: 'rectStroke',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'size', type: 'vec2' },
+                { name: 'strokeWidth', type: 'float' },
+        ],
+})
+
+export const rectStrokeUniform = Fn(([st, size, strokeWidth]: [Vec2, Float, Float]): Float => {
+        return stroke(rectSDFUniform(st, size), float(1), strokeWidth)
+}).setLayout({
+        name: 'rectStrokeUniform',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'size', type: 'float' },
+                { name: 'strokeWidth', type: 'float' },
+        ],
+})
+
+export const rectFill = Fn(([st, size]: [Vec2, Vec2]): Float => {
+        return fill(rectSDF(st, size), float(1))
+}).setLayout({
+        name: 'rectFill',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'size', type: 'vec2' },
+        ],
+})
+
+export const rectFillUniform = Fn(([st, size]: [Vec2, Float]): Float => {
+        return fill(rectSDFUniform(st, size), float(1))
+}).setLayout({
+        name: 'rectFillUniform',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'size', type: 'float' },
+        ],
+})
+
+export const rect = rectFill

package/src/addons/draw/stroke.ts

@@ -0,0 +1,31 @@
+import { Fn, Float, smoothstep, clamp } from '../../node'
+import { aastep } from '../math/aastep'
+
+export const strokeWithEdge = Fn(([x, size, w, edge]: [Float, Float, Float, Float]): Float => {
+        const d = smoothstep(size.sub(edge), size.add(edge), x.add(w.div(2))).sub(
+                smoothstep(size.sub(edge), size.add(edge), x.sub(w.div(2)))
+        )
+        return clamp(d, 0, 1)
+}).setLayout({
+        name: 'strokeWithEdge',
+        type: 'float',
+        inputs: [
+                { name: 'x', type: 'float' },
+                { name: 'size', type: 'float' },
+                { name: 'w', type: 'float' },
+                { name: 'edge', type: 'float' },
+        ],
+})
+
+export const stroke = Fn(([x, size, w]: [Float, Float, Float]): Float => {
+        const d = aastep(size, x.add(w.div(2))).sub(aastep(size, x.sub(w.div(2))))
+        return clamp(d, 0, 1)
+}).setLayout({
+        name: 'stroke',
+        type: 'float',
+        inputs: [
+                { name: 'x', type: 'float' },
+                { name: 'size', type: 'float' },
+                { name: 'w', type: 'float' },
+        ],
+})

package/src/addons/draw/tri.ts

@@ -0,0 +1,29 @@
+import { Fn, Vec2, Float } from '../../node'
+import { triSDF } from '../sdf/triSDF'
+import { fill } from './fill'
+import { stroke } from './stroke'
+
+export const triFill = Fn(([st, size]: [Vec2, Float]): Float => {
+        return fill(triSDF(st), size)
+}).setLayout({
+        name: 'triFill',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'size', type: 'float' },
+        ],
+})
+
+export const triStroke = Fn(([st, size, strokeWidth]: [Vec2, Float, Float]): Float => {
+        return stroke(triSDF(st), size, strokeWidth)
+}).setLayout({
+        name: 'triStroke',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'size', type: 'float' },
+                { name: 'strokeWidth', type: 'float' },
+        ],
+})
+
+export const tri = triFill

package/src/addons/generative/cnoise.ts

@@ -0,0 +1,239 @@
+import { Fn, Vec2, Vec3, Vec4, Float, vec2, vec3, vec4, mix, step } from '../../node'
+import { mod289Vec3, mod289Vec4 } from '../math/mod289'
+import { permuteVec4 } from '../math/permute'
+import { taylorInvSqrt } from '../math/taylorInvSqrt'
+import { quintic } from '../math/quintic'
+
+export const cnoiseVec2 = Fn(([P]: [Vec2]): Float => {
+        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(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)
+        return n_xy.mul(2.3)
+}).setLayout({
+        name: 'cnoiseVec2',
+        type: 'float',
+        inputs: [{ name: 'P', type: 'vec2' }],
+})
+
+export const cnoiseVec3 = Fn(([P]: [Vec3]): Float => {
+        const Pi0 = P.floor().toVar('Pi0')
+        const Pi1 = Pi0.add(vec3(1)).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)
+        return n_xyz.mul(2.2)
+}).setLayout({
+        name: 'cnoiseVec3',
+        type: 'float',
+        inputs: [{ name: 'P', type: 'vec3' }],
+})
+
+export const cnoiseVec4 = Fn(([P]: [Vec4]): Float => {
+        const Pi0 = P.floor().toVar('Pi0')
+        const Pi1 = Pi0.add(1).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(gx00.step(vec4(0)).sub(0.5)))
+        gy00.subAssign(sw00.mul(gy00.step(vec4(0)).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(gx01.step(vec4(0)).sub(0.5)))
+        gy01.subAssign(sw01.mul(gy01.step(vec4(0)).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(gx10.step(vec4(0)).sub(0.5)))
+        gy10.subAssign(sw10.mul(gy10.step(vec4(0)).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(gx11.step(vec4(0)).sub(0.5)))
+        gy11.subAssign(sw11.mul(gy11.step(vec4(0)).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)
+        return n_xyzw.mul(2.2)
+}).setLayout({
+        name: 'cnoiseVec4',
+        type: 'float',
+        inputs: [{ name: 'P', type: 'vec4' }],
+})