glre 0.38.0 → 0.40.0

package/src/addons/math/mmax.ts

@@ -0,0 +1,27 @@
+import { Fn, Vec2, Vec3, Vec4, Float, max } from '../../node'
+
+export const mmax2 = Fn(([v]: [Vec2]): Float => {
+        return max(v.x, v.y)
+}).setLayout({
+        name: 'mmax',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})
+
+export const mmax3 = Fn(([v]: [Vec3]): Float => {
+        return max(v.x, max(v.y, v.z))
+}).setLayout({
+        name: 'mmax',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})
+
+export const mmax4 = Fn(([v]: [Vec4]): Float => {
+        return max(max(v.x, v.y), max(v.z, v.w))
+}).setLayout({
+        name: 'mmax',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec4' }],
+})
+
+export const mmax = mmax4

package/src/addons/math/mmin.ts

@@ -0,0 +1,28 @@
+import { Fn, Vec2, Vec3, Vec4, Float, min } from '../../node'
+
+export const mmin2 = Fn(([v]: [Vec2]): Float => {
+        return min(v.x, v.y)
+}).setLayout({
+        name: 'mmin',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})
+
+export const mmin3 = Fn(([v]: [Vec3]): Float => {
+        return min(v.x, min(v.y, v.z))
+}).setLayout({
+        name: 'mmin',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})
+
+export const mmin4 = Fn(([v]: [Vec4]): Float => {
+        return min(min(v.x, v.y), min(v.z, v.w))
+}).setLayout({
+        name: 'mmin',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec4' }],
+})
+
+// Generic mmin function - delegates to specific implementations
+export const mmin = mmin4

package/src/addons/math/mmix.ts

@@ -0,0 +1,47 @@
+import { Fn, X, mix, max, step, clamp } from '../../node'
+
+// Basic mmix function - wrapper around standard mix
+export const mmix = Fn(([a, b, c]: [X, X, X]): X => {
+        return mix(a, b, c)
+}).setLayout({
+        name: 'mmix',
+        type: 'auto',
+        inputs: [
+                { name: 'a', type: 'auto' },
+                { name: 'b', type: 'auto' },
+                { name: 'c', type: 'auto' },
+        ],
+})
+
+// Three-value interpolation with percentage control
+export const mmix3 = Fn(([a, b, c, pct]: [X, X, X, X]): X => {
+        return mix(mix(a, b, pct.mul(2)), mix(b, c, max(pct, 0.5).sub(0.5).mul(2)), step(0.5, pct))
+}).setLayout({
+        name: 'mmix3',
+        type: 'auto',
+        inputs: [
+                { name: 'a', type: 'auto' },
+                { name: 'b', type: 'auto' },
+                { name: 'c', type: 'auto' },
+                { name: 'pct', type: 'auto' },
+        ],
+})
+
+// Four-value interpolation with percentage control
+export const mmix4 = Fn(([a, b, c, d, pct]: [X, X, X, X, X]): X => {
+        return mix(
+                mix(a, b, pct.mul(3)),
+                mix(b, mix(c, d, max(pct, 0.66).sub(0.66).mul(3)), clamp(pct, 0.33, 0.66).sub(0.33).mul(3)),
+                step(0.33, pct)
+        )
+}).setLayout({
+        name: 'mmix4',
+        type: 'auto',
+        inputs: [
+                { name: 'a', type: 'auto' },
+                { name: 'b', type: 'auto' },
+                { name: 'c', type: 'auto' },
+                { name: 'd', type: 'auto' },
+                { name: 'pct', type: 'auto' },
+        ],
+})

package/src/addons/math/mod2.ts

@@ -0,0 +1,44 @@
+import { Fn, Vec2, X, vec4 } from '../../node'
+
+// 2D modulo function that returns both cell coordinates and wrapped position
+// Returns vec4(cellX, cellY, wrappedX, wrappedY)
+export const mod2 = Fn(([p, s]: [Vec2, X]): X => {
+        const halfS = s.div(2).toVar()
+        const pShifted = p.add(halfS).toVar()
+        const c = pShifted.div(s).floor().toVar()
+        const wrapped = pShifted.mod(s).sub(halfS)
+        return vec4(c.x, c.y, wrapped.x, wrapped.y)
+}).setLayout({
+        name: 'mod2',
+        type: 'vec4',
+        inputs: [
+                { name: 'p', type: 'vec2' },
+                { name: 's', type: 'auto' },
+        ],
+})
+
+// Utility function to extract cell coordinates from mod2 result
+export const mod2Cell = Fn(([p, s]: [Vec2, X]): Vec2 => {
+        const result = mod2(p, s)
+        return result.xy
+}).setLayout({
+        name: 'mod2Cell',
+        type: 'vec2',
+        inputs: [
+                { name: 'p', type: 'vec2' },
+                { name: 's', type: 'auto' },
+        ],
+})
+
+// Utility function to extract wrapped position from mod2 result
+export const mod2Wrap = Fn(([p, s]: [Vec2, X]): Vec2 => {
+        const result = mod2(p, s)
+        return result.zw
+}).setLayout({
+        name: 'mod2Wrap',
+        type: 'vec2',
+        inputs: [
+                { name: 'p', type: 'vec2' },
+                { name: 's', type: 'auto' },
+        ],
+})

package/src/addons/math/mod289.ts

@@ -0,0 +1,46 @@
+import { Fn, Float, Vec2, Vec3, Vec4, X } from '../../node'
+
+function fun(x: Float): Float
+function fun(x: Vec2): Vec2
+function fun(x: Vec3): Vec3
+function fun(x: Vec4): Vec4
+function fun(x: X): X {
+        return x.sub(
+                x
+                        .div(289)
+                        .floor()
+                        .mul(289)
+        )
+}
+
+export const mod289 = Fn(([x]: [Float]): Float => {
+        return fun(x)
+}).setLayout({
+        name: 'mod289',
+        type: 'float',
+        inputs: [{ name: 'x', type: 'float' }],
+})
+
+export const mod289Vec2 = Fn(([x]: [Vec2]): Vec2 => {
+        return fun(x)
+}).setLayout({
+        name: 'mod289Vec2',
+        type: 'vec2',
+        inputs: [{ name: 'x', type: 'vec2' }],
+})
+
+export const mod289Vec3 = Fn(([x]: [Vec3]): Vec3 => {
+        return fun(x)
+}).setLayout({
+        name: 'mod289Vec3',
+        type: 'vec3',
+        inputs: [{ name: 'x', type: 'vec3' }],
+})
+
+export const mod289Vec4 = Fn(([x]: [Vec4]): Vec4 => {
+        return fun(x)
+}).setLayout({
+        name: 'mod289Vec4',
+        type: 'vec4',
+        inputs: [{ name: 'x', type: 'vec4' }],
+})

package/src/addons/math/modi.ts

@@ -0,0 +1,15 @@
+import { Fn, Int } from '../../node'
+
+export const modi = Fn(([x, y]: [Int, Int]): Int => {
+        const xf = x.toFloat()
+        const yf = y.toFloat()
+        const quotient = xf.div(yf).floor()
+        return x.sub(quotient.mul(yf).toInt())
+}).setLayout({
+        name: 'modi',
+        type: 'int',
+        inputs: [
+                { name: 'x', type: 'int' },
+                { name: 'y', type: 'int' },
+        ],
+})

package/src/addons/math/nyquist.ts

@@ -0,0 +1,15 @@
+import { Fn, Float, X, mix, smoothstep, float } from '../../node'
+
+export const nyquist = Fn(([x, width]: [X, Float]): X => {
+        const cutoffStart = 0.25
+        const cutoffEnd = 0.75
+        const f = smoothstep(cutoffEnd, cutoffStart, width)
+        return mix(float(0.5), x, f)
+}).setLayout({
+        name: 'nyquist',
+        type: 'auto',
+        inputs: [
+                { name: 'x', type: 'auto' },
+                { name: 'width', type: 'float' },
+        ],
+})

package/src/addons/math/pack.ts

@@ -0,0 +1,15 @@
+import { Fn, Float, Vec4, fract, vec3, vec4, float } from '../../node'
+
+const PackUpscale = float(256.0 / 255.0)
+const PackFactors = vec3(256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0)
+const ShiftRight8 = float(1 / 256)
+
+export const pack = Fn(([v]: [Float]): Vec4 => {
+        const r = vec4(fract(v.mul(PackFactors)), v).toVar()
+        r.yzw.assign(r.yzw.sub(r.xyz.mul(ShiftRight8)))
+        return r.mul(PackUpscale)
+}).setLayout({
+        name: 'pack',
+        type: 'vec4',
+        inputs: [{ name: 'v', type: 'float' }],
+})

package/src/addons/math/parabola.ts

@@ -0,0 +1,12 @@
+import { Fn, Float } from '../../node'
+
+export const parabola = Fn(([x, k]: [Float, Float]): Float => {
+        return x.mul(4).mul(x.oneMinus()).pow(k)
+}).setLayout({
+        name: 'parabola',
+        type: 'float',
+        inputs: [
+                { name: 'x', type: 'float' },
+                { name: 'k', type: 'float' },
+        ],
+})

package/src/addons/math/permute.ts

@@ -0,0 +1,42 @@
+import { Fn, Float, Vec2, Vec3, Vec4, X } from '../../node'
+import { mod289, mod289Vec2, mod289Vec3, mod289Vec4 } from './mod289'
+
+function fun(v: Float): Float
+function fun(v: Vec2): Vec2
+function fun(v: Vec3): Vec3
+function fun(v: Vec4): Vec4
+function fun(v: X): X {
+        return v.mul(34).add(1).mul(v)
+}
+
+export const permute = Fn(([v]: [Float]): Float => {
+        return mod289(fun(v))
+}).setLayout({
+        name: 'permute',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'float' }],
+})
+
+export const permuteVec2 = Fn(([v]: [Vec2]): Vec2 => {
+        return mod289Vec2(fun(v))
+}).setLayout({
+        name: 'permuteVec2',
+        type: 'vec2',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})
+
+export const permuteVec3 = Fn(([v]: [Vec3]): Vec3 => {
+        return mod289Vec3(fun(v))
+}).setLayout({
+        name: 'permuteVec3',
+        type: 'vec3',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})
+
+export const permuteVec4 = Fn(([v]: [Vec4]): Vec4 => {
+        return mod289Vec4(fun(v))
+}).setLayout({
+        name: 'permuteVec4',
+        type: 'vec4',
+        inputs: [{ name: 'v', type: 'vec4' }],
+})

package/src/addons/math/pow2.ts

@@ -0,0 +1,10 @@
+import { Fn, X } from '../../node'
+
+// Square function - computes x^2 with quadratic energy amplification
+export const pow2 = Fn(([v]: [X]): X => {
+        return v.mul(v)
+}).setLayout({
+        name: 'pow2',
+        type: 'auto',
+        inputs: [{ name: 'v', type: 'auto' }],
+})

package/src/addons/math/pow3.ts

@@ -0,0 +1,9 @@
+import { Fn, X } from '../../node'
+
+export const pow3 = Fn(([x]: [X]): X => {
+        return x.mul(x).mul(x)
+}).setLayout({
+        name: 'pow3',
+        type: 'auto',
+        inputs: [{ name: 'x', type: 'auto' }],
+})

package/src/addons/math/pow5.ts

@@ -0,0 +1,10 @@
+import { Fn, X } from '../../node'
+
+export const pow5 = Fn(([x]: [X]): X => {
+        const v2 = x.mul(x).toVar('v2')
+        return v2.mul(v2).mul(x)
+}).setLayout({
+        name: 'pow5',
+        type: 'auto',
+        inputs: [{ name: 'x', type: 'auto' }],
+})

package/src/addons/math/pow7.ts

@@ -0,0 +1,12 @@
+import { Fn, X } from '../../node'
+
+export const pow7 = Fn(([x]: [X]): X => {
+        const v2 = x.mul(x).toVar('v2')
+        const v4 = v2.mul(v2).toVar('v4')
+        const v6 = v4.mul(v2).toVar('v6')
+        return v6.mul(x)
+}).setLayout({
+        name: 'pow7',
+        type: 'auto',
+        inputs: [{ name: 'x', type: 'auto' }],
+})

package/src/addons/math/powFast.ts

@@ -0,0 +1,18 @@
+import { Fn, X, Float, float } from '../../node'
+
+export const powFast = Fn(([a, b]: [X, X]): X => {
+        return a.div((float(1) as any).sub(b).mul(a).add(b))
+}).setLayout({
+        name: 'powFast',
+        type: 'auto',
+        inputs: [
+                {
+                        name: 'a',
+                        type: 'auto'
+                },
+                {
+                        name: 'b', 
+                        type: 'auto'
+                }
+        ]
+})

package/src/addons/math/quartic.ts

@@ -0,0 +1,15 @@
+import { Fn, X, float } from '../../node'
+
+export const quartic = Fn(([v]: [X]): X => {
+	const v2 = v.mul(v).toVar('v2')
+	return v2.mul((float(2) as any).sub(v2))
+}).setLayout({
+	name: 'quartic',
+	type: 'auto',
+	inputs: [
+		{
+			name: 'v',
+			type: 'auto'
+		}
+	]
+})

package/src/addons/math/quat/index.ts

@@ -0,0 +1,14 @@
+export * from './quat2mat3'
+export * from './quat2mat4'
+export * from './quatAdd'
+export * from './quatConj'
+export * from './quatDiv'
+export * from './quatIdentity'
+export * from './quatInverse'
+export * from './quatLength'
+export * from './quatLengthSq'
+export * from './quatLerp'
+export * from './quatMul'
+export * from './quatNeg'
+export * from './quatNorm'
+export * from './quatSub'

package/src/addons/math/quat/quat2mat3.ts

@@ -0,0 +1,28 @@
+import { Fn, Vec4, Mat3, mat3, vec3, float } from '../../../node'
+
+export const quat2mat3 = Fn(([q]: [Vec4]): Mat3 => {
+        const qxx = q.x.mul(q.x).toVar('qxx')
+        const qyy = q.y.mul(q.y).toVar('qyy')
+        const qzz = q.z.mul(q.z).toVar('qzz')
+        const qxz = q.x.mul(q.z).toVar('qxz')
+        const qxy = q.x.mul(q.y).toVar('qxy')
+        const qyw = q.y.mul(q.w).toVar('qyw')
+        const qzw = q.z.mul(q.w).toVar('qzw')
+        const qyz = q.y.mul(q.z).toVar('qyz')
+        const qxw = q.x.mul(q.w).toVar('qxw')
+
+        return mat3(
+                vec3(float(1).sub(float(2).mul(qyy.add(qzz))), float(2).mul(qxy.sub(qzw)), float(2).mul(qxz.add(qyw))),
+                vec3(float(2).mul(qxy.add(qzw)), float(1).sub(float(2).mul(qxx.add(qzz))), float(2).mul(qyz.sub(qxw))),
+                vec3(float(2).mul(qxz.sub(qyw)), float(2).mul(qyz.add(qxw)), float(1).sub(float(2).mul(qxx.add(qyy))))
+        )
+}).setLayout({
+        name: 'quat2mat3',
+        type: 'mat3',
+        inputs: [
+                {
+                        name: 'q',
+                        type: 'vec4',
+                },
+        ],
+})

package/src/addons/math/quat/quat2mat4.ts

@@ -0,0 +1,16 @@
+import { Fn, Vec4, Mat4 } from '../../../node'
+import { quat2mat3 } from './quat2mat3'
+import { toMat4 } from '../toMat4'
+
+export const quat2mat4 = Fn(([q]: [Vec4]): Mat4 => {
+        return toMat4(quat2mat3(q))
+}).setLayout({
+        name: 'quat2mat4',
+        type: 'mat4',
+        inputs: [
+                {
+                        name: 'q',
+                        type: 'vec4',
+                },
+        ],
+})

package/src/addons/math/quat/quatAdd.ts

@@ -0,0 +1,18 @@
+import { Fn, Vec4, vec4 } from '../../../node'
+
+export const quatAdd = Fn(([a, b]: [Vec4, Vec4]): Vec4 => {
+        return vec4(a.xyz.add(b.xyz), a.w.add(b.w))
+}).setLayout({
+        name: 'quatAdd',
+        type: 'vec4',
+        inputs: [
+                {
+                        name: 'a',
+                        type: 'vec4',
+                },
+                {
+                        name: 'b',
+                        type: 'vec4',
+                },
+        ],
+})

package/src/addons/math/quat/quatConj.ts

@@ -0,0 +1,14 @@
+import { Fn, Vec4, vec4 } from '../../../node'
+
+export const quatConj = Fn(([q]: [Vec4]): Vec4 => {
+        return vec4(q.xyz.negate(), q.w)
+}).setLayout({
+        name: 'quatConj',
+        type: 'vec4',
+        inputs: [
+                {
+                        name: 'q',
+                        type: 'vec4',
+                },
+        ],
+})

package/src/addons/math/quat/quatDiv.ts

@@ -0,0 +1,18 @@
+import { Fn, Vec4, Float, vec4 } from '../../../node'
+
+export const quatDiv = Fn(([q, s]: [Vec4, Float]): Vec4 => {
+        return vec4(q.xyz.div(s), q.w.div(s))
+}).setLayout({
+        name: 'quatDiv',
+        type: 'vec4',
+        inputs: [
+                {
+                        name: 'q',
+                        type: 'vec4',
+                },
+                {
+                        name: 's',
+                        type: 'float',
+                },
+        ],
+})

package/src/addons/math/quat/quatIdentity.ts

@@ -0,0 +1,9 @@
+import { Fn, Vec4, vec4 } from '../../../node'
+
+export const quatIdentity = Fn(([]): Vec4 => {
+        return vec4(0, 0, 0, 1)
+}).setLayout({
+        name: 'quatIdentity',
+        type: 'vec4',
+        inputs: [],
+})

package/src/addons/math/quat/quatInverse.ts

@@ -0,0 +1,17 @@
+import { Fn, Vec4 } from '../../../node'
+import { quatDiv } from './quatDiv'
+import { quatConj } from './quatConj'
+import { quatLengthSq } from './quatLengthSq'
+
+export const quatInverse = Fn(([q]: [Vec4]): Vec4 => {
+        return quatDiv(quatConj(q), quatLengthSq(q))
+}).setLayout({
+        name: 'quatInverse',
+        type: 'vec4',
+        inputs: [
+                {
+                        name: 'q',
+                        type: 'vec4',
+                },
+        ],
+})

package/src/addons/math/quat/quatLength.ts

@@ -0,0 +1,15 @@
+import { Fn, Vec4, Float } from '../../../node'
+import { quatLengthSq } from './quatLengthSq'
+
+export const quatLength = Fn(([q]: [Vec4]): Float => {
+        return quatLengthSq(q).sqrt()
+}).setLayout({
+        name: 'quatLength',
+        type: 'float',
+        inputs: [
+                {
+                        name: 'q',
+                        type: 'vec4',
+                },
+        ],
+})

package/src/addons/math/quat/quatLengthSq.ts

@@ -0,0 +1,14 @@
+import { Fn, Vec4, Float } from '../../../node'
+
+export const quatLengthSq = Fn(([q]: [Vec4]): Float => {
+        return q.xyz.dot(q.xyz).add(q.w.mul(q.w))
+}).setLayout({
+        name: 'quatLengthSq',
+        type: 'float',
+        inputs: [
+                {
+                        name: 'q',
+                        type: 'vec4',
+                },
+        ],
+})

package/src/addons/math/quat/quatLerp.ts

@@ -0,0 +1,40 @@
+import { Fn, Vec4, Float, vec4, If, Return, float } from '../../../node'
+
+export const quatLerp = Fn(([qa, qb, t]: [Vec4, Vec4, Float]): Vec4 => {
+        const cosHalfTheta = qa.w.mul(qb.w).add(qa.xyz.dot(qb.xyz)).toVar('cosHalfTheta')
+        const adjustedQb = qb.negate().select(qb, cosHalfTheta.lessThan(0)).toVar('adjustedQb')
+        const absCosHalfTheta = cosHalfTheta.abs().toVar('absCosHalfTheta')
+
+        If(absCosHalfTheta.greaterThanEqual(1), () => {
+                Return(qa)
+        })
+
+        const halfTheta = absCosHalfTheta.acos().toVar('halfTheta')
+        const sinHalfTheta = float(1).sub(absCosHalfTheta.mul(absCosHalfTheta)).sqrt().toVar('sinHalfTheta')
+
+        If(sinHalfTheta.abs().lessThan(0.001), () => {
+                Return(qa.div(2).add(adjustedQb.div(2)).normalize())
+        })
+
+        const ratioA = float(1).sub(t).mul(halfTheta).sin().div(sinHalfTheta).toVar('ratioA')
+        const ratioB = t.mul(halfTheta).sin().div(sinHalfTheta).toVar('ratioB')
+
+        return qa.mul(ratioA).add(adjustedQb.mul(ratioB)).normalize()
+}).setLayout({
+        name: 'quatLerp',
+        type: 'vec4',
+        inputs: [
+                {
+                        name: 'qa',
+                        type: 'vec4',
+                },
+                {
+                        name: 'qb',
+                        type: 'vec4',
+                },
+                {
+                        name: 't',
+                        type: 'float',
+                },
+        ],
+})

package/src/addons/math/quat/quatMul.ts

@@ -0,0 +1,38 @@
+import { Fn, Vec4, Float, vec4 } from '../../../node'
+
+export const quatMul = Fn(([q1, q2]: [Vec4, Vec4]): Vec4 => {
+        return vec4(
+                q2.xyz.mul(q1.w).add(q1.xyz.mul(q2.w)).add(q1.xyz.cross(q2.xyz)),
+                q1.w.mul(q2.w).sub(q1.xyz.dot(q2.xyz))
+        )
+}).setLayout({
+        name: 'quatMul',
+        type: 'vec4',
+        inputs: [
+                {
+                        name: 'q1',
+                        type: 'vec4',
+                },
+                {
+                        name: 'q2',
+                        type: 'vec4',
+                },
+        ],
+})
+
+export const quatMulScalar = Fn(([q, s]: [Vec4, Float]): Vec4 => {
+        return vec4(q.xyz.mul(s), q.w.mul(s))
+}).setLayout({
+        name: 'quatMulScalar',
+        type: 'vec4',
+        inputs: [
+                {
+                        name: 'q',
+                        type: 'vec4',
+                },
+                {
+                        name: 's',
+                        type: 'float',
+                },
+        ],
+})

package/src/addons/math/quat/quatNeg.ts

@@ -0,0 +1,14 @@
+import { Fn, Vec4, vec4 } from '../../../node'
+
+export const quatNeg = Fn(([q]: [Vec4]): Vec4 => {
+        return vec4(q.xyz.negate(), q.w.negate())
+}).setLayout({
+        name: 'quatNeg',
+        type: 'vec4',
+        inputs: [
+                {
+                        name: 'q',
+                        type: 'vec4',
+                },
+        ],
+})