glre 0.41.0 → 0.42.0

package/src/addons/draw/digits.ts

@@ -0,0 +1,334 @@
+import { Fn, Float, Vec2, Vec3, Vec4, Mat2, Int, If, Loop, Break, float, vec2, int } from '../../node'
+
+const DIGITS_SIZE = vec2(0.02)
+const DIGITS_DECIMALS = float(2.0)
+const DIGITS_VALUE_OFFSET = vec2(-6.0, 3.0)
+
+const digitsCore = Fn(([st, value, nDecDigit]: [Vec2, Float, Float]): Float => {
+        const adjustedSt = st.div(DIGITS_SIZE).toVar('adjustedSt')
+        const absValue = value.abs().toVar('absValue')
+        const biggestDigitIndex = absValue.log2().div(float(10).log2()).floor().max(0).toVar('biggestDigitIndex')
+        const counter = absValue.floor().toVar('counter')
+        const nIntDigits = float(1).toVar('nIntDigits')
+
+        Loop(int(9), () => {
+                counter.assign(counter.mul(0.1).floor())
+                nIntDigits.addAssign(1)
+                If(counter.equal(0), () => {
+                        Break()
+                })
+        })
+
+        let digit = float(12).toVar('digit')
+        const digitIndex = nIntDigits.sub(1).sub(adjustedSt.x.floor()).toVar('digitIndex')
+
+        If(digitIndex.greaterThan(nDecDigit.negate().sub(1.5)), () => {
+                If(digitIndex.greaterThan(biggestDigitIndex), () => {
+                        If(value.lessThan(0), () => {
+                                If(digitIndex.lessThan(biggestDigitIndex.add(1.5)), () => {
+                                        digit.assign(11)
+                                })
+                        })
+                }).Else(() => {
+                        If(digitIndex.equal(-1), () => {
+                                If(nDecDigit.greaterThan(0), () => {
+                                        digit.assign(10)
+                                })
+                        }).Else(() => {
+                                If(digitIndex.lessThan(0), () => {
+                                        digitIndex.addAssign(1)
+                                })
+                                const digitValue = absValue.div(float(10).pow(digitIndex)).toVar('digitValue')
+                                digit.assign(digitValue.add(0.0001).floor().mod(10))
+                        })
+                })
+        })
+
+        const pos = vec2(adjustedSt.x.fract(), adjustedSt.y).toVar('pos')
+        If(pos.x.lessThan(0), () => {
+                return float(0)
+        })
+        If(pos.y.lessThan(0), () => {
+                return float(0)
+        })
+        If(pos.x.greaterThanEqual(1), () => {
+                return float(0)
+        })
+        If(pos.y.greaterThanEqual(1), () => {
+                return float(0)
+        })
+
+        const bin = float(0).toVar('bin')
+
+        If(digit.lessThan(0.5), () => {
+                bin.assign(
+                        float(7)
+                                .add(float(5).mul(16))
+                                .add(float(5).mul(256))
+                                .add(float(5).mul(4096))
+                                .add(float(7).mul(65536))
+                )
+        })
+                .ElseIf(digit.lessThan(1.5), () => {
+                        bin.assign(
+                                float(2)
+                                        .add(float(2).mul(16))
+                                        .add(float(2).mul(256))
+                                        .add(float(2).mul(4096))
+                                        .add(float(2).mul(65536))
+                        )
+                })
+                .ElseIf(digit.lessThan(2.5), () => {
+                        bin.assign(
+                                float(7)
+                                        .add(float(1).mul(16))
+                                        .add(float(7).mul(256))
+                                        .add(float(4).mul(4096))
+                                        .add(float(7).mul(65536))
+                        )
+                })
+                .ElseIf(digit.lessThan(3.5), () => {
+                        bin.assign(
+                                float(7)
+                                        .add(float(4).mul(16))
+                                        .add(float(7).mul(256))
+                                        .add(float(4).mul(4096))
+                                        .add(float(7).mul(65536))
+                        )
+                })
+                .ElseIf(digit.lessThan(4.5), () => {
+                        bin.assign(
+                                float(4)
+                                        .add(float(7).mul(16))
+                                        .add(float(5).mul(256))
+                                        .add(float(1).mul(4096))
+                                        .add(float(1).mul(65536))
+                        )
+                })
+                .ElseIf(digit.lessThan(5.5), () => {
+                        bin.assign(
+                                float(7)
+                                        .add(float(4).mul(16))
+                                        .add(float(7).mul(256))
+                                        .add(float(1).mul(4096))
+                                        .add(float(7).mul(65536))
+                        )
+                })
+                .ElseIf(digit.lessThan(6.5), () => {
+                        bin.assign(
+                                float(7)
+                                        .add(float(5).mul(16))
+                                        .add(float(7).mul(256))
+                                        .add(float(1).mul(4096))
+                                        .add(float(7).mul(65536))
+                        )
+                })
+                .ElseIf(digit.lessThan(7.5), () => {
+                        bin.assign(
+                                float(4)
+                                        .add(float(4).mul(16))
+                                        .add(float(4).mul(256))
+                                        .add(float(4).mul(4096))
+                                        .add(float(7).mul(65536))
+                        )
+                })
+                .ElseIf(digit.lessThan(8.5), () => {
+                        bin.assign(
+                                float(7)
+                                        .add(float(5).mul(16))
+                                        .add(float(7).mul(256))
+                                        .add(float(5).mul(4096))
+                                        .add(float(7).mul(65536))
+                        )
+                })
+                .ElseIf(digit.lessThan(9.5), () => {
+                        bin.assign(
+                                float(7)
+                                        .add(float(4).mul(16))
+                                        .add(float(7).mul(256))
+                                        .add(float(5).mul(4096))
+                                        .add(float(7).mul(65536))
+                        )
+                })
+                .ElseIf(digit.lessThan(10.5), () => {
+                        bin.assign(
+                                float(2)
+                                        .add(float(0).mul(16))
+                                        .add(float(0).mul(256))
+                                        .add(float(0).mul(4096))
+                                        .add(float(0).mul(65536))
+                        )
+                })
+                .ElseIf(digit.lessThan(11.5), () => {
+                        bin.assign(
+                                float(0)
+                                        .add(float(0).mul(16))
+                                        .add(float(7).mul(256))
+                                        .add(float(0).mul(4096))
+                                        .add(float(0).mul(65536))
+                        )
+                })
+
+        const pixel = pos.mul(vec2(4, 5)).floor().toVar('pixel')
+        return bin
+                .div(float(2).pow(pixel.x.add(pixel.y.mul(4))))
+                .floor()
+                .mod(2)
+}).setLayout({
+        name: 'digitsCore',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'value', type: 'float' },
+                { name: 'nDecDigit', type: 'float' },
+        ],
+})
+
+export const digitsFloat = Fn(([st, value, nDecDigit]: [Vec2, Float, Float]): Float => {
+        return digitsCore(st, value, nDecDigit)
+}).setLayout({
+        name: 'digitsFloat',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'value', type: 'float' },
+                { name: 'nDecDigit', type: 'float' },
+        ],
+})
+
+export const digitsInt = Fn(([st, value]: [Vec2, Int]): Float => {
+        return digitsCore(st, value.toFloat(), float(0))
+}).setLayout({
+        name: 'digitsInt',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'value', type: 'int' },
+        ],
+})
+
+export const digits = Fn(([st, value]: [Vec2, Float]): Float => {
+        return digitsCore(st, value, DIGITS_DECIMALS)
+}).setLayout({
+        name: 'digits',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'value', type: 'float' },
+        ],
+})
+
+export const digitsVec2 = Fn(([st, v]: [Vec2, Vec2]): Float => {
+        let rta = float(0).toVar('rta')
+        Loop(int(2), ({ i }) => {
+                const pos = st.add(vec2(i.toFloat(), 0).mul(DIGITS_SIZE).mul(DIGITS_VALUE_OFFSET)).toVar('pos')
+                let value = float(0).toVar('value')
+                If(i.equal(int(0)), () => {
+                        value.assign(v.x)
+                }).Else(() => {
+                        value.assign(v.y)
+                })
+                rta.addAssign(digits(pos, value))
+        })
+        return rta
+}).setLayout({
+        name: 'digitsVec2',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'v', type: 'vec2' },
+        ],
+})
+
+export const digitsVec3 = Fn(([st, v]: [Vec2, Vec3]): Float => {
+        let rta = float(0).toVar('rta')
+        Loop(int(3), ({ i }) => {
+                const pos = st.add(vec2(i.toFloat(), 0).mul(DIGITS_SIZE).mul(DIGITS_VALUE_OFFSET)).toVar('pos')
+                let value = float(0).toVar('value')
+                If(i.equal(int(0)), () => {
+                        value.assign(v.x)
+                })
+                        .ElseIf(i.equal(1), () => {
+                                value.assign(v.y)
+                        })
+                        .Else(() => {
+                                value.assign(v.z)
+                        })
+                rta.addAssign(digits(pos, value))
+        })
+        return rta
+}).setLayout({
+        name: 'digitsVec3',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'v', type: 'vec3' },
+        ],
+})
+
+export const digitsVec4 = Fn(([st, v]: [Vec2, Vec4]): Float => {
+        let rta = float(0).toVar('rta')
+        Loop(int(4), ({ i }) => {
+                const pos = st.add(vec2(i.toFloat(), 0).mul(DIGITS_SIZE).mul(DIGITS_VALUE_OFFSET)).toVar('pos')
+                let value = float(0).toVar('value')
+                If(i.equal(0), () => {
+                        value.assign(v.x)
+                })
+                        .ElseIf(i.equal(1), () => {
+                                value.assign(v.y)
+                        })
+                        .ElseIf(i.equal(2), () => {
+                                value.assign(v.z)
+                        })
+                        .Else(() => {
+                                value.assign(v.w)
+                        })
+                rta.addAssign(digits(pos, value))
+        })
+        return rta
+}).setLayout({
+        name: 'digitsVec4',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'v', type: 'vec4' },
+        ],
+})
+
+export const digitsMat2 = Fn(([st, matrix]: [Vec2, Mat2]): Float => {
+        let rta = float(0).toVar('rta')
+        // Manually unroll the matrix elements
+        const pos00 = st
+                .add(vec2(0, 0).mul(DIGITS_SIZE).mul(DIGITS_VALUE_OFFSET))
+                .sub(DIGITS_SIZE.mul(vec2(0, 3)))
+                .toVar('pos00')
+        const pos01 = st
+                .add(vec2(0, 1).mul(DIGITS_SIZE).mul(DIGITS_VALUE_OFFSET))
+                .sub(DIGITS_SIZE.mul(vec2(0, 3)))
+                .toVar('pos01')
+        const pos10 = st
+                .add(vec2(1, 0).mul(DIGITS_SIZE).mul(DIGITS_VALUE_OFFSET))
+                .sub(DIGITS_SIZE.mul(vec2(0, 3)))
+                .toVar('pos10')
+        const pos11 = st
+                .add(vec2(1, 1).mul(DIGITS_SIZE).mul(DIGITS_VALUE_OFFSET))
+                .sub(DIGITS_SIZE.mul(vec2(0, 3)))
+                .toVar('pos11')
+
+        rta.addAssign(digits(pos00, matrix.element(int(0)).element(int(0))))
+        rta.addAssign(digits(pos01, matrix.element(int(1)).element(int(0))))
+        rta.addAssign(digits(pos10, matrix.element(int(0)).element(int(1))))
+        rta.addAssign(digits(pos11, matrix.element(int(1)).element(int(1))))
+
+        return rta
+}).setLayout({
+        name: 'digitsMat2',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'matrix', type: 'mat2' },
+        ],
+})
+
+// Note: Mat3 and Mat4 display functions are omitted for simplicity
+// due to complexity in matrix element access. Only Mat2 is implemented.

package/src/addons/draw/index.ts

@@ -3,10 +3,14 @@ export * from './axis'
 export * from './bridge'
 export * from './char'
 export * from './circle'
+export * from './colorChecker'
+export * from './colorPicker'
+export * from './digits'
 export * from './fill'
 export * from './flip'
 export * from './hex'
 export * from './line'
+export * from './matrix'
 export * from './point'
 export * from './rect'
 export * from './stroke'

package/src/addons/draw/matrix.ts

@@ -0,0 +1,26 @@
+import { Fn, Vec2, Vec4, Mat2, vec2, step, vec4 } from '../../node'
+import { digitsMat2 } from './digits'
+
+const DIGITS_SIZE = vec2(0.02)
+const DIGITS_VALUE_OFFSET = vec2(-6.0, 3.0)
+
+export const matrix = Fn(([st, M]: [Vec2, Mat2]): Vec4 => {
+        const rta = vec4(0).toVar('rta')
+        const size = DIGITS_SIZE.mul(DIGITS_VALUE_OFFSET.abs()).mul(2)
+        rta.a.assign(
+                step(DIGITS_SIZE.x.negate(), st.x)
+                        .mul(step(st.x, size.x))
+                        .mul(step(DIGITS_SIZE.y.negate(), st.y))
+                        .mul(step(st.y, size.y))
+                        .mul(0.5)
+        )
+        rta.assign(rta.add(digitsMat2(st, M)))
+        return rta
+}).setLayout({
+        name: 'matrixMat2',
+        type: 'vec4',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'M', type: 'mat2' },
+        ],
+})

package/src/addons/draw/point.ts

@@ -1,12 +1,27 @@
-import { Fn, Vec2, Vec3, Vec4, Float, vec3, vec4, float } from '../../node'
+import { Fn, Vec2, Vec3, Vec4, Float, vec2, vec3, vec4, float, step } from '../../node'
+import { digitsVec2 } from './digits'
 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)
+const DIGITS_SIZE = vec2(0.02)
+const DIGITS_VALUE_OFFSET = vec2(-6.0, 3.0)
+
+export const pointWithColor = Fn(([st, pos, color, radius]: [Vec2, Vec2, Vec3, Float]): Vec4 => {
+        const rta = vec4(0).toVar('rta')
+        const st_p = st.sub(pos).toVar('st_p')
+        rta.assign(rta.add(vec4(color, 1).mul(circleFill(st_p.add(0.5), radius))))
+        st_p.assign(st_p.sub(DIGITS_SIZE.mul(vec2(0, 0.5))))
+        const size = DIGITS_SIZE.mul(DIGITS_VALUE_OFFSET.abs()).mul(vec2(2, 0.5))
+        rta.a.addAssign(
+                step(0, st_p.x)
+                        .mul(step(st_p.x, size.x))
+                        .mul(step(DIGITS_SIZE.y.mul(-0.5), st_p.y))
+                        .mul(step(st_p.y, size.y))
+                        .mul(0.5)
+        )
+        rta.assign(rta.add(digitsVec2(st_p, pos)))
+        return rta
 }).setLayout({
-        name: 'point2D',
+        name: 'pointWithColor',
         type: 'vec4',
         inputs: [
                 { name: 'st', type: 'vec2' },
@@ -16,15 +31,13 @@ export const point2D = Fn(([st, pos, color, radius]: [Vec2, Vec2, Vec3, Float]):
         ],
 })
 
-export const pointSimple = Fn(([st, pos]: [Vec2, Vec2]): Vec4 => {
-        return point2D(st, pos, vec3(1, 0, 0), float(0.02))
+export const point = Fn(([st, pos]: [Vec2, Vec2]): Vec4 => {
+        return pointWithColor(st, pos, vec3(1, 0, 0), float(0.02))
 }).setLayout({
-        name: 'pointSimple',
+        name: 'point',
         type: 'vec4',
         inputs: [
                 { name: 'st', type: 'vec2' },
                 { name: 'pos', type: 'vec2' },
         ],
 })
-
-export const point = pointSimple

package/src/addons/geometry/triangle/closestPoint.ts

@@ -1,4 +1,4 @@
-import { Fn, Vec3, dot, length, cross, normalize, max, min, vec3, float, If, Return } from '../../../node'
+import { Fn, Vec3, dot, length, cross, normalize, max, min, vec3, float, If } from '../../../node'
 import { barycentricFromVec3 } from './barycentric'
 import { TriangleType } from './triangle'
 
@@ -16,20 +16,20 @@ export const closestPointWithNormal = Fn(([tri, triNormal, pos]: [TriangleType,
                 const bc = c.sub(b).toVar('bc')
                 const n = length(bc).toVar('n')
                 const t = max(float(0), min(dot(bc, p.sub(b)).div(n), n)).toVar('t')
-                Return(b.add(t.div(n).mul(bc)))
+                return b.add(t.div(n).mul(bc))
         })
 
         If(bcoords.y.lessThan(0), () => {
                 const ca = a.sub(c).toVar('ca')
                 const n = length(ca).toVar('n')
                 const t = max(float(0), min(dot(ca, p.sub(c)).div(n), n)).toVar('t')
-                Return(c.add(t.div(n).mul(ca)))
+                return c.add(t.div(n).mul(ca))
         })
 
         If(bcoords.z.lessThan(0), () => {
                 const n = length(ab).toVar('n')
                 const t = max(float(0), min(dot(ab, p.sub(a)).div(n), n)).toVar('t')
-                Return(a.add(t.div(n).mul(ab)))
+                return a.add(t.div(n).mul(ab))
         })
 
         return a.mul(bcoords.x).add(b.mul(bcoords.y)).add(c.mul(bcoords.z))
@@ -58,20 +58,20 @@ export const closestPoint = Fn(([tri, pos]: [TriangleType, Vec3]): Vec3 => {
                 const bc = c.sub(b).toVar('bc')
                 const n = length(bc).toVar('n')
                 const t = max(float(0), min(dot(bc, p.sub(b)).div(n), n)).toVar('t')
-                Return(b.add(t.div(n).mul(bc)))
+                return b.add(t.div(n).mul(bc))
         })
 
         If(bcoords.y.lessThan(0), () => {
                 const ca = a.sub(c).toVar('ca')
                 const n = length(ca).toVar('n')
                 const t = max(float(0), min(dot(ca, p.sub(c)).div(n), n)).toVar('t')
-                Return(c.add(t.div(n).mul(ca)))
+                return c.add(t.div(n).mul(ca))
         })
 
         If(bcoords.z.lessThan(0), () => {
                 const n = length(ab).toVar('n')
                 const t = max(float(0), min(dot(ab, p.sub(a)).div(n), n)).toVar('t')
-                Return(a.add(t.div(n).mul(ab)))
+                return a.add(t.div(n).mul(ab))
         })
 
         return a.mul(bcoords.x).add(b.mul(bcoords.y)).add(c.mul(bcoords.z))

package/src/addons/index.ts

@@ -1,6 +1,9 @@
 export * from './animation/easing'
+export * from './color/blend'
+export * from './color/composite'
 export * from './color/space'
 export * from './draw'
+export * from './draw/digits'
 export * from './geometry'
 export * from './generative'
 export * from './math'

package/src/addons/math/const.ts

@@ -1,12 +1,12 @@
-import { float } from "../../node"
+import { float } from '../../node'
 
 // Mathematical constants as float nodes
 export const EIGHTH_PI = float(0.39269908169)
 export const QTR_PI = float(0.78539816339)
 export const HALF_PI = float(1.5707963267948966192313216916398)
 export const PI = float(3.1415926535897932384626433832795)
-export const TWO_PI = float(6.2831853071795864769252867665590)
-export const TAU = float(6.2831853071795864769252867665590)
+export const TWO_PI = float(6.283185307179586476925286766559)
+export const TAU = float(6.283185307179586476925286766559)
 export const INV_PI = float(0.31830988618379067153776752674503)
 export const INV_SQRT_TAU = float(0.39894228040143267793994605993439)
 export const SQRT_HALF_PI = float(1.25331413732)
@@ -16,4 +16,4 @@ export const GOLDEN_RATIO = float(1.6180339887)
 export const GOLDEN_RATIO_CONJUGATE = float(0.61803398875)
 export const GOLDEN_ANGLE = float(2.39996323)
 export const DEG2RAD = PI.div(180)
-export const RAD2DEG = float(180).div(PI)
+export const RAD2DEG = float(180).div(PI)

package/src/addons/math/mod289.ts

@@ -5,12 +5,7 @@ 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)
-        )
+        return x.sub(x.div(289).floor().mul(289))
 }
 
 export const mod289 = Fn(([x]: [Float]): Float => {

package/src/addons/math/powFast.ts

@@ -6,13 +6,7 @@ export const powFast = Fn(([a, b]: [X, X]): X => {
         name: 'powFast',
         type: 'auto',
         inputs: [
-                {
-                        name: 'a',
-                        type: 'auto'
-                },
-                {
-                        name: 'b', 
-                        type: 'auto'
-                }
-        ]
-})
+                { name: 'a', type: 'auto' },
+                { name: 'b', type: 'auto' },
+        ],
+})

package/src/addons/math/quartic.ts

@@ -1,15 +1,10 @@
 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))
+        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'
-		}
-	]
-})
+        name: 'quartic',
+        type: 'auto',
+        inputs: [{ name: 'v', type: 'auto' }],
+})

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

@@ -1,4 +1,4 @@
-import { Fn, Vec4, Float, vec4, If, Return, float } from '../../../node'
+import { Fn, Vec4, Float, If, 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')
@@ -6,14 +6,14 @@ export const quatLerp = Fn(([qa, qb, t]: [Vec4, Vec4, Float]): Vec4 => {
         const absCosHalfTheta = cosHalfTheta.abs().toVar('absCosHalfTheta')
 
         If(absCosHalfTheta.greaterThanEqual(1), () => {
-                Return(qa)
+                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())
+                return qa.div(2).add(adjustedQb.div(2)).normalize()
         })
 
         const ratioA = float(1).sub(t).mul(halfTheta).sin().div(sinHalfTheta).toVar('ratioA')

package/src/addons/math/quintic.ts

@@ -1,16 +1,11 @@
 import { Fn, X } from '../../node'
 
 export const quintic = Fn(([v]: [X]): X => {
-	const v3 = v.mul(v).mul(v).toVar('v3')
-	const inner = v.mul(v.mul(6).sub(15)).add(10).toVar('inner')
-	return v3.mul(inner)
+        const v3 = v.mul(v).mul(v).toVar('v3')
+        const inner = v.mul(v.mul(6).sub(15)).add(10).toVar('inner')
+        return v3.mul(inner)
 }).setLayout({
-	name: 'quintic',
-	type: 'auto',
-	inputs: [
-		{
-			name: 'v',
-			type: 'auto'
-		}
-	]
-})
+        name: 'quintic',
+        type: 'auto',
+        inputs: [{ name: 'v', type: 'auto' }],
+})

package/src/addons/math/rotate2d.ts

@@ -7,10 +7,5 @@ export const rotate2d = Fn(([r]: [Float]): Mat2 => {
 }).setLayout({
         name: 'rotate2d',
         type: 'mat2',
-        inputs: [
-                {
-                        name: 'r',
-                        type: 'float',
-                },
-        ],
+        inputs: [{ name: 'r', type: 'float' }],
 })

package/src/addons/math/rotate3d.ts

@@ -25,13 +25,7 @@ export const rotate3d = Fn(([a, r]: [Vec3, Float]): Mat3 => {
         name: 'rotate3d',
         type: 'mat3',
         inputs: [
-                {
-                        name: 'a',
-                        type: 'vec3'
-                },
-                {
-                        name: 'r',
-                        type: 'float'
-                }
-        ]
-})
+                { name: 'a', type: 'vec3' },
+                { name: 'r', type: 'float' },
+        ],
+})

package/src/addons/math/rotate3dX.ts

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