glre 0.39.0 → 0.40.0

package/src/addons/math/rotate3dZ.ts

@@ -0,0 +1,20 @@
+import { Fn, Float, Mat3, mat3, vec3 } from '../../node'
+
+export const rotate3dZ = Fn(([r]: [Float]): Mat3 => {
+        const c = r.cos()
+        const s = r.sin()
+        return mat3(
+                vec3(c, s, 0),
+                vec3(s.negate(), c, 0),
+                vec3(0, 0, 1)
+        )
+}).setLayout({
+        name: 'rotate3dZ',
+        type: 'mat3',
+        inputs: [
+                {
+                        name: 'r',
+                        type: 'float'
+                }
+        ]
+})

package/src/addons/math/rotate4d.ts

@@ -0,0 +1,41 @@
+import { Fn, Float, Mat4, Vec3, float, mat4, vec4 } from '../../node'
+
+export const rotate4d = Fn(([a, r]: [Vec3, Float]): Mat4 => {
+        const axis = a.normalize().toVar('axis')
+        const s = r.sin().toVar('s')
+        const c = r.cos().toVar('c')
+        const oc = float(1).sub(c).toVar('oc')
+        const col1 = vec4(
+                oc.mul(axis.x).mul(axis.x).add(c),
+                oc.mul(axis.x).mul(axis.y).add(axis.z.mul(s)),
+                oc.mul(axis.z).mul(axis.x).sub(axis.y.mul(s)),
+                0
+        )
+        const col2 = vec4(
+                oc.mul(axis.x).mul(axis.y).sub(axis.z.mul(s)),
+                oc.mul(axis.y).mul(axis.y).add(c),
+                oc.mul(axis.y).mul(axis.z).add(axis.x.mul(s)),
+                0
+        )
+        const col3 = vec4(
+                oc.mul(axis.z).mul(axis.x).add(axis.y.mul(s)),
+                oc.mul(axis.y).mul(axis.z).sub(axis.x.mul(s)),
+                oc.mul(axis.z).mul(axis.z).add(c),
+                0
+        )
+        const col4 = vec4(0, 0, 0, 1)
+        return mat4(col1, col2, col3, col4)
+}).setLayout({
+        name: 'rotate4d',
+        type: 'mat4',
+        inputs: [
+                {
+                        name: 'a',
+                        type: 'vec3'
+                },
+                {
+                        name: 'r',
+                        type: 'float'
+                }
+        ]
+})

package/src/addons/math/rotate4dX.ts

@@ -0,0 +1,21 @@
+import { Fn, Float, Mat4, mat4, vec4 } from '../../node'
+
+export const rotate4dX = Fn(([r]: [Float]): Mat4 => {
+        const c = r.cos()
+        const s = r.sin()
+        return mat4(
+                vec4(1, 0, 0, 0),
+                vec4(0, c, s, 0),
+                vec4(0, s.negate(), c, 0),
+                vec4(0, 0, 0, 1)
+        )
+}).setLayout({
+        name: 'rotate4dX',
+        type: 'mat4',
+        inputs: [
+                {
+                        name: 'r',
+                        type: 'float'
+                }
+        ]
+})

package/src/addons/math/rotate4dY.ts

@@ -0,0 +1,16 @@
+import { Fn, Float, Mat4, mat4, vec4 } from '../../node'
+
+export const rotate4dY = Fn(([r]: [Float]): Mat4 => {
+        const c = r.cos()
+        const s = r.sin()
+        return mat4(vec4(c, 0, s.negate(), 0), vec4(0, 1, 0, 0), vec4(s, 0, c, 0), vec4(0, 0, 0, 1))
+}).setLayout({
+        name: 'rotate4dY',
+        type: 'mat4',
+        inputs: [
+                {
+                        name: 'r',
+                        type: 'float',
+                },
+        ],
+})

package/src/addons/math/rotate4dZ.ts

@@ -0,0 +1,21 @@
+import { Fn, Float, Mat4, mat4, vec4 } from '../../node'
+
+export const rotate4dZ = Fn(([r]: [Float]): Mat4 => {
+        const c = r.cos()
+        const s = r.sin()
+        return mat4(
+                vec4(c, s, 0, 0),
+                vec4(s.negate(), c, 0, 0),
+                vec4(0, 0, 1, 0),
+                vec4(0, 0, 0, 1)
+        )
+}).setLayout({
+        name: 'rotate4dZ',
+        type: 'mat4',
+        inputs: [
+                {
+                        name: 'r',
+                        type: 'float'
+                }
+        ]
+})

package/src/addons/math/saturateMediump.ts

@@ -0,0 +1,11 @@
+import { Fn, X, float } from '../../node'
+
+const MEDIUMP_FLT_MAX = float(65504.0)
+
+export const saturateMediump = Fn(([x]: [X]): X => {
+	return x.min(MEDIUMP_FLT_MAX)
+}).setLayout({
+	name: 'saturateMediump',
+	type: 'auto',
+	inputs: [{ name: 'x', type: 'auto' }],
+})

package/src/addons/math/scale2d.ts

@@ -0,0 +1,44 @@
+import { Fn, Float, Vec2, mat2, Mat2 } from '../../node'
+
+export const scale2d = Fn(([s]: [Float]): Mat2 => {
+    return mat2(s, 0, 0, s)
+}).setLayout({
+    name: 'scale2d',
+    type: 'mat2',
+    inputs: [
+        {
+            name: 's',
+            type: 'float',
+        },
+    ]
+})
+
+export const scale2dVec = Fn(([s]: [Vec2]): Mat2 => {
+    return mat2(s.x, 0, 0, s.y)
+}).setLayout({
+    name: 'scale2d',
+    type: 'mat2',
+    inputs: [
+        {
+            name: 's',
+            type: 'vec2',
+        },
+    ]
+})
+
+export const scale2dXY = Fn(([x, y]: [Float, Float]): Mat2 => {
+    return mat2(x, 0, 0, y)
+}).setLayout({
+    name: 'scale2d',
+    type: 'mat2',
+    inputs: [
+        {
+            name: 'x',
+            type: 'float',
+        },
+        {
+            name: 'y', 
+            type: 'float',
+        },
+    ]
+})

package/src/addons/math/scale3d.ts

@@ -0,0 +1,17 @@
+import { Fn, Float, Vec3, Mat3, mat3 } from '../../node'
+
+export const scale3d = Fn(([s]: [Float]): Mat3 => {
+        return mat3(s, 0, 0, 0, s, 0, 0, 0, s)
+}).setLayout({
+        name: 'scale3d',
+        type: 'mat3',
+        inputs: [{ name: 's', type: 'float' }]
+})
+
+export const scale3dVec = Fn(([s]: [Vec3]): Mat3 => {
+        return mat3(s.x, 0, 0, 0, s.y, 0, 0, 0, s.z)
+}).setLayout({
+        name: 'scale3d',
+        type: 'mat3',
+        inputs: [{ name: 's', type: 'vec3' }]
+})

package/src/addons/math/scale4d.ts

@@ -0,0 +1,50 @@
+import { Fn, Float, Vec3, Vec4, Mat4, mat4 } from '../../node'
+
+export const scale4d = Fn(([s]: [Float]): Mat4 => {
+        return mat4(s, 0, 0, 0, 0, s, 0, 0, 0, 0, s, 0, 0, 0, 0, 1)
+}).setLayout({
+        name: 'scale4d',
+        type: 'mat4',
+        inputs: [{ name: 's', type: 'float' }]
+})
+
+export const scale4dXYZ = Fn(([x, y, z]: [Float, Float, Float]): Mat4 => {
+        return mat4(x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1)
+}).setLayout({
+        name: 'scale4d',
+        type: 'mat4',
+        inputs: [
+                { name: 'x', type: 'float' },
+                { name: 'y', type: 'float' },
+                { name: 'z', type: 'float' }
+        ]
+})
+
+export const scale4dXYZW = Fn(([x, y, z, w]: [Float, Float, Float, Float]): Mat4 => {
+        return mat4(x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, w)
+}).setLayout({
+        name: 'scale4d',
+        type: 'mat4',
+        inputs: [
+                { name: 'x', type: 'float' },
+                { name: 'y', type: 'float' },
+                { name: 'z', type: 'float' },
+                { name: 'w', type: 'float' }
+        ]
+})
+
+export const scale4dVec3 = Fn(([s]: [Vec3]): Mat4 => {
+        return mat4(s.x, 0, 0, 0, 0, s.y, 0, 0, 0, 0, s.z, 0, 0, 0, 0, 1)
+}).setLayout({
+        name: 'scale4d',
+        type: 'mat4',
+        inputs: [{ name: 's', type: 'vec3' }]
+})
+
+export const scale4dVec4 = Fn(([s]: [Vec4]): Mat4 => {
+        return mat4(s.x, 0, 0, 0, 0, s.y, 0, 0, 0, 0, s.z, 0, 0, 0, 0, s.w)
+}).setLayout({
+        name: 'scale4d',
+        type: 'mat4',
+        inputs: [{ name: 's', type: 'vec4' }]
+})

package/src/addons/math/smootherstep.ts

@@ -0,0 +1,16 @@
+import { Fn, X } from '../../node'
+import { quintic } from './quintic'
+
+export const smootherstep = Fn(([a, b, v]: [X, X, X]): X => {
+	const normalized = v.sub(a).div(b.sub(a)).toVar('normalized')
+	const saturated = normalized.saturate().toVar('saturated')
+	return quintic(saturated)
+}).setLayout({
+	name: 'smootherstep',
+	type: 'auto',
+	inputs: [
+		{ name: 'a', type: 'auto' },
+		{ name: 'b', type: 'auto' },
+		{ name: 'v', type: 'auto' }
+	]
+})

package/src/addons/math/taylorInvSqrt.ts

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

package/src/addons/math/toMat3.ts

@@ -0,0 +1,14 @@
+import { Fn, Mat3, Mat4, mat3 } from '../../node'
+
+export const toMat3 = Fn(([m]: [Mat4]): Mat3 => {
+        return mat3(m[0].xyz, m[1].xyz, m[2].xyz)
+}).setLayout({
+        name: 'toMat3',
+        type: 'mat3',
+        inputs: [
+                {
+                        name: 'm',
+                        type: 'mat4',
+                },
+        ],
+})

package/src/addons/math/toMat4.ts

@@ -0,0 +1,14 @@
+import { Fn, Mat3, Mat4, mat4, vec4 } from '../../node'
+
+export const toMat4 = Fn(([m]: [Mat3]): Mat4 => {
+        return mat4(vec4(m[0], 0), vec4(m[1], 0), vec4(m[2], 0), vec4(0, 0, 0, 1))
+}).setLayout({
+        name: 'toMat4',
+        type: 'mat4',
+        inputs: [
+                {
+                        name: 'm',
+                        type: 'mat3',
+                },
+        ],
+})

package/src/addons/math/translate4d.ts

@@ -0,0 +1,31 @@
+import { Fn, Float, Mat4, Vec3, X, mat4 } from '../../node'
+
+export const translate4d = Fn(([x, y, z]: [X, X?, X?]): Mat4 => {
+        if (y === undefined && z === undefined) {
+                const t = x as Vec3
+                return mat4(
+                        1, 0, 0, 0,
+                        0, 1, 0, 0,
+                        0, 0, 1, 0,
+                        t.x, t.y, t.z, 1
+                )
+        } else {
+                const tx = x as Float
+                const ty = y as Float
+                const tz = z as Float
+                return mat4(
+                        1, 0, 0, 0,
+                        0, 1, 0, 0,
+                        0, 0, 1, 0,
+                        tx, ty, tz, 1
+                )
+        }
+}).setLayout({
+        name: 'translate4d',
+        type: 'mat4',
+        inputs: [
+                { name: 'x', type: 'auto' },
+                { name: 'y', type: 'auto' },
+                { name: 'z', type: 'auto' }
+        ]
+})

package/src/addons/math/unpack.ts

@@ -0,0 +1,88 @@
+import { Fn, Float, Vec3, Vec4, dot, vec3, vec4, float } from '../../node'
+
+const UnpackDownscale = float(255.0 / 256.0)
+const PackFactors = vec3(256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0)
+const UnpackFactors = UnpackDownscale.div(vec4(PackFactors, 1.0))
+
+export const unpack8 = Fn(([v]: [Vec3]): Float => {
+        const f = vec3(8, 8 * 8, 8 * 8 * 8)
+        return dot(v, f).div(512.0)
+}).setLayout({
+        name: 'unpack8',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})
+
+export const unpack16 = Fn(([v]: [Vec3]): Float => {
+        const f = vec3(16, 16 * 16, 16 * 16 * 16)
+        return dot(v, f).div(4096.0)
+}).setLayout({
+        name: 'unpack16',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})
+
+export const unpack32 = Fn(([v]: [Vec3]): Float => {
+        const f = vec3(32, 32 * 32, 32 * 32 * 32)
+        return dot(v, f).div(32768.0)
+}).setLayout({
+        name: 'unpack32',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})
+
+export const unpack64 = Fn(([v]: [Vec3]): Float => {
+        const f = vec3(64, 64 * 64, 64 * 64 * 64)
+        return dot(v, f).div(262144.0)
+}).setLayout({
+        name: 'unpack64',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})
+
+export const unpack128 = Fn(([v]: [Vec3]): Float => {
+        const f = vec3(128, 128 * 128, 128 * 128 * 128)
+        return dot(v, f).div(2097152.0)
+}).setLayout({
+        name: 'unpack128',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})
+
+export const unpack256 = Fn(([v]: [Vec3]): Float => {
+        const f = vec3(256, 256 * 256, 256 * 256 * 256)
+        return dot(v, f).div(16581375.0)
+}).setLayout({
+        name: 'unpack256',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})
+
+export const unpackBase = Fn(([v, base]: [Vec3, Float]): Float => {
+        const base3 = base.mul(base).mul(base)
+        const f = vec3(base, base.mul(base), base3)
+        return dot(v, f).div(base3)
+}).setLayout({
+        name: 'unpackBase',
+        type: 'float',
+        inputs: [
+                { name: 'v', type: 'vec3' },
+                { name: 'base', type: 'float' },
+        ],
+})
+
+export const unpack = Fn(([v]: [Vec4]): Float => {
+        return dot(v, UnpackFactors)
+}).setLayout({
+        name: 'unpack',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec4' }],
+})
+
+export const unpackDefault = Fn(([v]: [Vec3]): Float => {
+        return unpack256(v)
+}).setLayout({
+        name: 'unpackDefault',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})

package/src/addons/sdf/boxSDF.ts

@@ -0,0 +1,24 @@
+import { Fn, Vec3 } from '../../node'
+
+export const boxSDF = Fn(([p]: [Vec3]) => {
+        const d = p.abs().toVar()
+        return d.x.max(d.y.max(d.z)).min(0).add(d.max(0).length())
+}).setLayout({
+        name: 'boxSDF',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' }
+        ]
+})
+
+export const boxSDFSize = Fn(([p, b]: [Vec3, Vec3]) => {
+        const d = p.abs().sub(b).toVar()
+        return d.x.max(d.y.max(d.z)).min(0).add(d.max(0).length())
+}).setLayout({
+        name: 'boxSDFSize',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'b', type: 'vec3' }
+        ]
+})

package/src/addons/sdf/circleSDF.ts

@@ -0,0 +1,20 @@
+import { Fn, Vec2, vec2 } from '../../node'
+
+export const circleSDF = Fn(([v, center]: [Vec2, Vec2]) => {
+        return v.sub(center).length().mul(2)
+}).setLayout({
+        name: 'circleSDF',
+        type: 'float',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 'center', type: 'vec2' },
+        ],
+})
+
+export const circleSDFBasic = Fn(([v]: [Vec2]) => {
+        return v.sub(vec2(0.5)).length().mul(2)
+}).setLayout({
+        name: 'circleSDFBasic',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})

package/src/addons/sdf/crossSDF.ts

@@ -0,0 +1,17 @@
+import { Fn, vec2, min, Float, Vec2 } from '../../node'
+import { rectSDF } from './rectSDF'
+
+export const crossSDF = Fn(([st, s]: [Vec2, Float]): Float => {
+        const size = vec2(0.25, s)
+        return min(
+                rectSDF(st, size),
+                rectSDF(st, size.yx)
+        )
+}).setLayout({
+        name: 'crossSDF',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 's', type: 'float' }
+        ]
+})

package/src/addons/sdf/hexSDF.ts

@@ -0,0 +1,18 @@
+import { Fn, Vec2, Float, abs, max, float } from '../../node'
+
+export const hexSDF = Fn(([st]: [Vec2]): Float => {
+	// Transform to centered coordinates [-1, 1]
+	const normalized = st.mul(2).sub(1).toVar()
+	normalized.assign(abs(normalized))
+	
+	// Hexagon SDF calculation using geometric properties
+	const sqrt3_2 = float(0.866025) // sqrt(3)/2
+	return max(
+		abs(normalized.y), 
+		normalized.x.mul(sqrt3_2).add(normalized.y.div(2))
+	)
+}).setLayout({
+	name: 'hexSDF',
+	type: 'float',
+	inputs: [{ name: 'st', type: 'vec2' }],
+})

package/src/addons/sdf/index.ts

@@ -0,0 +1,7 @@
+export * from './circleSDF'
+export * from './sphereSDF'
+export * from './rectSDF'
+export * from './boxSDF'
+export * from './lineSDF'
+export * from './hexSDF'
+export * from './triSDF'

package/src/addons/sdf/lineSDF.ts

@@ -0,0 +1,33 @@
+import { Fn, Vec2, Vec3, Float, clamp, dot, length, cross } from '../../node'
+
+// 2D line segment distance function
+export const lineSDF2D = Fn(([st, a, b]: [Vec2, Vec2, Vec2]): Float => {
+        const b_to_a = b.sub(a).toVar('b_to_a')
+        const to_a = st.sub(a).toVar('to_a')
+        const h = clamp(dot(to_a, b_to_a).div(dot(b_to_a, b_to_a)), 0, 1).toVar('h')
+        return length(to_a.sub(h.mul(b_to_a)))
+}).setLayout({
+        name: 'lineSDF2D',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'a', type: 'vec2' },
+                { name: 'b', type: 'vec2' },
+        ],
+})
+
+// 3D line distance function
+export const lineSDF3D = Fn(([p, a, b]: [Vec3, Vec3, Vec3]): Float => {
+        return length(cross(p.sub(a), p.sub(b))).div(length(b.sub(a)))
+}).setLayout({
+        name: 'lineSDF3D',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'a', type: 'vec3' },
+                { name: 'b', type: 'vec3' },
+        ],
+})
+
+// Unified lineSDF function (defaults to 2D)
+export const lineSDF = lineSDF2D

package/src/addons/sdf/rectSDF.ts

@@ -0,0 +1,46 @@
+import { Fn, Vec2, Float, vec2 } from '../../node'
+
+export const rectSDFBasic = Fn(([st]: [Vec2]) => {
+        const normalizedSt = st.mul(2).sub(1).toVar()
+        return normalizedSt.x.abs().max(normalizedSt.y.abs())
+}).setLayout({
+        name: 'rectSDFBasic',
+        type: 'float',
+        inputs: [{ name: 'st', type: 'vec2' }],
+})
+
+export const rectSDF = Fn(([st, s]: [Vec2, Vec2]) => {
+        const normalizedSt = st.mul(2).sub(1).toVar()
+        return normalizedSt.x.div(s.x).abs().max(normalizedSt.y.div(s.y).abs())
+}).setLayout({
+        name: 'rectSDF',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 's', type: 'vec2' },
+        ],
+})
+
+export const rectSDFUniform = Fn(([st, s]: [Vec2, Float]) => {
+        return rectSDF(st, vec2(s))
+}).setLayout({
+        name: 'rectSDFUniform',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 's', type: 'float' },
+        ],
+})
+
+export const rectSDFRounded = Fn(([p, b, r]: [Vec2, Vec2, Float]) => {
+        const d = p.sub(0.5).mul(4.2).abs().sub(b).add(vec2(r)).toVar()
+        return d.x.max(d.y).min(0).add(d.max(0).length()).sub(r)
+}).setLayout({
+        name: 'rectSDFRounded',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec2' },
+                { name: 'b', type: 'vec2' },
+                { name: 'r', type: 'float' },
+        ],
+})

package/src/addons/sdf/sphereSDF.ts

@@ -0,0 +1,20 @@
+import { Fn, Vec3, Float } from '../../node'
+
+export const sphereSDF = Fn(([p]: [Vec3]) => {
+        return p.length()
+}).setLayout({
+        name: 'sphereSDF',
+        type: 'float',
+        inputs: [{ name: 'p', type: 'vec3' }],
+})
+
+export const sphereSDFRadius = Fn(([p, s]: [Vec3, Float]) => {
+        return p.length().sub(s)
+}).setLayout({
+        name: 'sphereSDFRadius',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 's', type: 'float' },
+        ],
+})

package/src/addons/sdf/triSDF.ts

@@ -0,0 +1,14 @@
+import { Fn, Vec2, Float, max, abs, float } from '../../node'
+
+export const triSDF = Fn(([st]: [Vec2]): Float => {
+	const normalized = st.sub(0.5).mul(5).toVar()
+	const sqrt3_2 = float(0.866025) // sqrt(3)/2
+	return max(
+		abs(normalized.x).mul(sqrt3_2).add(normalized.y.div(2)),
+		normalized.y.div(-2)
+	)
+}).setLayout({
+	name: 'triSDF',
+	type: 'float',
+	inputs: [{ name: 'st', type: 'vec2' }],
+})

package/src/addons/space/aspect.ts

@@ -0,0 +1,14 @@
+import { Fn, Vec2 } from '../../node'
+
+export const aspect = Fn(([st, s]: [Vec2, Vec2]): Vec2 => {
+        const result = st.toVar('result')
+        result.x.assign(result.x.mul(s.x.div(s.y)))
+        return result
+}).setLayout({
+        name: 'aspect',
+        type: 'vec2',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 's', type: 'vec2' }
+        ]
+})