glre 0.41.0 → 0.43.0

package/src/addons/sdf/icosahedronSDF.ts

@@ -0,0 +1,23 @@
+import { Fn, Vec3, Float, vec3 } from '../../node'
+
+export const icosahedronSDF = Fn(([p, radius]: [Vec3, Float]): Float => {
+        const phi = 2.61803398875 // Golden ratio constant (φ + 1)
+        const n1 = vec3(phi, 1, 0).normalize().toVar('n1')
+        const n2 = vec3(0.57735026919).toVar('n2') // 1/sqrt(3)
+
+        const normalizedP = p.abs().div(radius).toVar('normalizedP')
+
+        const a = normalizedP.dot(n1).toVar('a')
+        const b = normalizedP.dot(vec3(n1.z, n1.x, n1.y)).toVar('b')
+        const c = normalizedP.dot(vec3(n1.y, n1.z, n1.x)).toVar('c')
+        const d = normalizedP.dot(n2).sub(n1.x).toVar('d')
+
+        return a.max(b).max(c).sub(n1.x).max(d).mul(radius)
+}).setLayout({
+        name: 'icosahedronSDF',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'radius', type: 'float' },
+        ],
+})

package/src/addons/sdf/index.ts

@@ -1,7 +1,48 @@
+export * from './arrowSDF'
+export * from './boxFrameSDF'
+export * from './capsuleSDF'
 export * from './circleSDF'
+export * from './coneSDF'
+export * from './crossSDF'
+export * from './cubeSDF'
+export * from './cylinderSDF'
+export * from './dodecahedronSDF'
+export * from './ellipsoidSDF'
+export * from './flowerSDF'
+export * from './gearSDF'
+export * from './heartSDF'
+export * from './hexPrismSDF'
+export * from './icosahedronSDF'
+export * from './juliaSDF'
+export * from './kochSDF'
+export * from './linkSDF'
+export * from './mandelbulbSDF'
+export * from './octahedronSDF'
+export * from './octogonPrismSDF'
+export * from './opElongate'
+export * from './opExtrude'
+export * from './opIntersection'
+export * from './opOnion'
+export * from './opRepeat'
+export * from './opRevolve'
+export * from './opRound'
+export * from './opSubtraction'
+export * from './opUnion'
+export * from './planeSDF'
+export * from './polySDF'
+export * from './pyramidSDF'
+export * from './raysSDF'
+export * from './rhombSDF'
+export * from './spiralSDF'
+export * from './starSDF'
+export * from './superShapeSDF'
+export * from './tetrahedronSDF'
+export * from './triPrismSDF'
 export * from './sphereSDF'
 export * from './rectSDF'
 export * from './boxSDF'
 export * from './lineSDF'
 export * from './hexSDF'
+export * from './torusSDF'
 export * from './triSDF'
+export * from './vesicaSDF'

package/src/addons/sdf/juliaSDF.ts

@@ -0,0 +1,39 @@
+import { Fn, Vec2, Float, vec2, float, Loop, If, Break } from '../../node'
+
+export const juliaSDF = Fn(([st, center, c, r]: [Vec2, Vec2, Vec2, Float]): Float => {
+        const transformed = st.sub(0.5).mul(2).toVar('transformed')
+        const z = vec2(0).sub(transformed).mul(r).toVar('z')
+        const n = float(0).toVar('n')
+        const maxIter = 500
+
+        Loop(maxIter, ({ i }) => {
+                If(z.length().greaterThan(4), () => {
+                        n.assign(i.toFloat().div(maxIter))
+                        Break()
+                })
+                z.assign(vec2(z.x.pow(2).sub(z.y.pow(2)).add(c.x), z.x.mul(z.y).mul(2).add(c.y)))
+        })
+
+        return n
+}).setLayout({
+        name: 'juliaSDF',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'center', type: 'vec2' },
+                { name: 'c', type: 'vec2' },
+                { name: 'r', type: 'float' },
+        ],
+})
+
+export const juliaSDFSimple = Fn(([st, c, r]: [Vec2, Vec2, Float]): Float => {
+        return juliaSDF(st, vec2(0.5), c, r)
+}).setLayout({
+        name: 'juliaSDFSimple',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'c', type: 'vec2' },
+                { name: 'r', type: 'float' },
+        ],
+})

package/src/addons/sdf/kochSDF.ts

@@ -0,0 +1,49 @@
+import { Fn, Vec2, Int, Float, vec2, mat2, float, Loop, Break, If } from '../../node'
+
+export const kochSDF = Fn(([st, center, N]: [Vec2, Vec2, Int]): Float => {
+        st = st.sub(center).toVar()
+        st.assign(st.mul(3))
+        const r3 = float(3).sqrt().toVar('r3')
+        st.assign(st.abs())
+        st.assign(st.add(r3.mul(vec2(st.y.negate(), st.x))))
+        st.assign(vec2(st.x, st.y.sub(1)))
+        const w = float(0.5).toVar('w')
+        const m = mat2(r3, 3, -3, r3).mul(0.5).toVar('m')
+
+        Loop(20, ({ i }) => {
+                If(i.toFloat().greaterThanEqual(N.toFloat()), () => {
+                        Break()
+                })
+                st.assign(
+                        vec2(r3.negate(), 3)
+                                .mul(0.5)
+                                .sub(m.mul(vec2(st.y, st.x.abs())))
+                )
+                w.assign(w.div(r3))
+        })
+
+        const d = st.y
+                .sign()
+                .mul(vec2(st.y, st.x.abs().sub(r3).max(0)).length())
+                .toVar('d')
+        return d.mul(w)
+}).setLayout({
+        name: 'kochSDF',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'center', type: 'vec2' },
+                { name: 'N', type: 'int' },
+        ],
+})
+
+export const kochSDFSimple = Fn(([st, N]: [Vec2, Int]): Float => {
+        return kochSDF(st, vec2(0.5), N)
+}).setLayout({
+        name: 'kochSDFSimple',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'N', type: 'int' },
+        ],
+})

package/src/addons/sdf/linkSDF.ts

@@ -0,0 +1,15 @@
+import { Fn, Vec3, Float, vec3, vec2 } from '../../node'
+
+export const linkSDF = Fn(([p, le, r1, r2]: [Vec3, Float, Float, Float]): Float => {
+        const q = vec3(p.x, p.y.abs().sub(le).max(0), p.z).toVar('q')
+        return vec2(vec2(q.x, q.y).length().sub(r1), q.z).length().sub(r2)
+}).setLayout({
+        name: 'linkSDF',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'le', type: 'float' },
+                { name: 'r1', type: 'float' },
+                { name: 'r2', type: 'float' },
+        ],
+})

package/src/addons/sdf/mandelbulbSDF.ts

@@ -0,0 +1,41 @@
+import { Fn, Vec3, Vec2, vec2, vec3, float, Loop, If, Break } from '../../node'
+import { cart2polar3D } from '../space/cart2polar'
+
+export const mandelbulbSDF = Fn(([st]: [Vec3]): Vec2 => {
+        const zeta = st.toVar('zeta')
+        const m = st.dot(st).toVar('m')
+        const dz = float(1).toVar('dz')
+        const n = float(8).toVar('n')
+        const maxiterations = 20
+        const iterations = float(0).toVar('iterations')
+        const r = float(0).toVar('r')
+        const dr = float(1).toVar('dr')
+
+        Loop(maxiterations, () => {
+                dz.assign(n.mul(m.pow(3.5)).mul(dz).add(1))
+                const sphericalZ = cart2polar3D(zeta).toVar('sphericalZ')
+                const newx = sphericalZ.x
+                        .pow(n)
+                        .mul(sphericalZ.y.mul(n).sin())
+                        .mul(sphericalZ.z.mul(n).cos())
+                        .toVar('newx')
+                const newy = sphericalZ.x
+                        .pow(n)
+                        .mul(sphericalZ.y.mul(n).sin())
+                        .mul(sphericalZ.z.mul(n).sin())
+                        .toVar('newy')
+                const newz = sphericalZ.x.pow(n).mul(sphericalZ.y.mul(n).cos()).toVar('newz')
+                zeta.assign(vec3(newx.add(st.x), newy.add(st.y), newz.add(st.z)))
+                m.assign(zeta.dot(zeta))
+                If(m.greaterThan(2), () => {
+                        Break()
+                })
+                iterations.assign(iterations.add(1))
+        })
+
+        return vec2(float(0.25).mul(m.log()).mul(m.sqrt()).div(dz), iterations)
+}).setLayout({
+        name: 'mandelbulbSDF',
+        type: 'vec2',
+        inputs: [{ name: 'st', type: 'vec3' }],
+})

package/src/addons/sdf/octahedronSDF.ts

@@ -0,0 +1,30 @@
+import { Fn, Vec3, Float } from '../../node'
+
+export const octahedronSDF = Fn(([p, s]: [Vec3, Float]): Float => {
+        const pAbs = p.abs().toVar('pAbs')
+        const m = pAbs.x.add(pAbs.y).add(pAbs.z).sub(s).toVar('m')
+        return m.mul(0.57735027)
+}).setLayout({
+        name: 'octahedronSDF',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 's', type: 'float' },
+        ],
+})
+
+export const octahedronSDFExact = Fn(([p, s]: [Vec3, Float]): Float => {
+        const pAbs = p.abs().toVar('pAbs')
+        const m = pAbs.x.add(pAbs.y).add(pAbs.z).sub(s).toVar('m')
+        const o = pAbs.mul(3).sub(m).min(0).toVar('o')
+        o.assign(pAbs.mul(6).sub(m.mul(2)).sub(o.mul(3)).add(o.x.add(o.y).add(o.z)).max(0))
+        const oSum = o.x.add(o.y).add(o.z).toVar('oSum')
+        return pAbs.sub(s.mul(o).div(oSum)).length()
+}).setLayout({
+        name: 'octahedronSDFExact',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 's', type: 'float' },
+        ],
+})

package/src/addons/sdf/octogonPrismSDF.ts

@@ -0,0 +1,19 @@
+import { Fn, Vec3, Float, vec3, vec2 } from '../../node'
+
+export const octogonPrismSDF = Fn(([p, r, h]: [Vec3, Float, Float]): Float => {
+        const k = vec3(-0.9238795325, 0.3826834323, 0.4142135623).toVar('k')
+        p.assign(p.abs())
+        p.assign(vec3(p.xy.sub(vec2(k.x, k.y).mul(vec2(k.x, k.y).dot(p.xy).min(0).mul(2))), p.z))
+        p.assign(vec3(p.xy.sub(vec2(k.x.negate(), k.y).mul(vec2(k.x.negate(), k.y).dot(p.xy).min(0).mul(2))), p.z))
+        p.assign(vec3(p.xy.sub(vec2(p.x.clamp(k.z.negate().mul(r), k.z.mul(r)), r)), p.z))
+        const d = vec2(p.xy.length().mul(p.y.sign()), p.z.sub(h)).toVar('d')
+        return d.x.max(d.y).min(0).add(d.max(0).length())
+}).setLayout({
+        name: 'octogonPrismSDF',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'r', type: 'float' },
+                { name: 'h', type: 'float' },
+        ],
+})

package/src/addons/sdf/opElongate.ts

@@ -0,0 +1,35 @@
+import { Fn, Vec2, Vec3, Vec4, vec4 } from '../../node'
+
+export const opElongateVec2 = Fn(([p, h]: [Vec2, Vec2]): Vec2 => {
+        return p.sub(p.clamp(h.negate(), h))
+}).setLayout({
+        name: 'opElongateVec2',
+        type: 'vec2',
+        inputs: [
+                { name: 'p', type: 'vec2' },
+                { name: 'h', type: 'vec2' }
+        ]
+})
+
+export const opElongateVec3 = Fn(([p, h]: [Vec3, Vec3]): Vec3 => {
+        return p.sub(p.clamp(h.negate(), h))
+}).setLayout({
+        name: 'opElongateVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'h', type: 'vec3' }
+        ]
+})
+
+export const opElongateVec4 = Fn(([p, h]: [Vec4, Vec4]): Vec4 => {
+        const q = p.abs().sub(h).toVar('q')
+        return vec4(q.max(0), q.x.max(q.y.max(q.z)).min(0))
+}).setLayout({
+        name: 'opElongateVec4',
+        type: 'vec4',
+        inputs: [
+                { name: 'p', type: 'vec4' },
+                { name: 'h', type: 'vec4' }
+        ]
+})

package/src/addons/sdf/opExtrude.ts

@@ -0,0 +1,14 @@
+import { Fn, Vec3, Float, vec2 } from '../../node'
+
+export const opExtrude = Fn(([p, sdf, h]: [Vec3, Float, Float]): Float => {
+        const w = vec2(sdf, p.z.abs().sub(h)).toVar('w')
+        return w.x.max(w.y).min(0).add(w.max(0).length())
+}).setLayout({
+        name: 'opExtrude',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'sdf', type: 'float' },
+                { name: 'h', type: 'float' },
+        ],
+})

package/src/addons/sdf/opIntersection.ts

@@ -0,0 +1,25 @@
+import { Fn, Float, mix, float } from '../../node'
+
+export const opIntersection = Fn(([d1, d2]: [Float, Float]): Float => {
+        return d1.max(d2)
+}).setLayout({
+        name: 'opIntersection',
+        type: 'float',
+        inputs: [
+                { name: 'd1', type: 'float' },
+                { name: 'd2', type: 'float' },
+        ],
+})
+
+export const opIntersectionSmooth = Fn(([d1, d2, k]: [Float, Float, Float]): Float => {
+        const h = float(0.5).sub(d2.sub(d1).div(k).mul(0.5)).saturate().toVar('h')
+        return mix(d2, d1, h).add(k.mul(h).mul(h.oneMinus()))
+}).setLayout({
+        name: 'opIntersectionSmooth',
+        type: 'float',
+        inputs: [
+                { name: 'd1', type: 'float' },
+                { name: 'd2', type: 'float' },
+                { name: 'k', type: 'float' },
+        ],
+})

package/src/addons/sdf/opOnion.ts

@@ -0,0 +1,12 @@
+import { Fn, Float } from '../../node'
+
+export const opOnion = Fn(([d, h]: [Float, Float]): Float => {
+        return d.abs().sub(h)
+}).setLayout({
+        name: 'opOnion',
+        type: 'float',
+        inputs: [
+                { name: 'd', type: 'float' },
+                { name: 'h', type: 'float' },
+        ],
+})

package/src/addons/sdf/opRepeat.ts

@@ -0,0 +1,49 @@
+import { Fn, Vec2, Vec3, Float, mod } from '../../node'
+
+export const opRepeatVec2 = Fn(([p, s]: [Vec2, Float]): Vec2 => {
+        return mod(p.add(s.mul(0.5)), s).sub(s.mul(0.5))
+}).setLayout({
+        name: 'opRepeatVec2',
+        type: 'vec2',
+        inputs: [
+                { name: 'p', type: 'vec2' },
+                { name: 's', type: 'float' }
+        ]
+})
+
+export const opRepeatVec3 = Fn(([p, c]: [Vec3, Vec3]): Vec3 => {
+        return mod(p.add(c.mul(0.5)), c).sub(c.mul(0.5))
+}).setLayout({
+        name: 'opRepeatVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'c', type: 'vec3' }
+        ]
+})
+
+export const opRepeatVec2Limited = Fn(([p, lima, limb, s]: [Vec2, Vec2, Vec2, Float]): Vec2 => {
+        return p.sub(s.mul(p.div(s).floor().clamp(lima, limb)))
+}).setLayout({
+        name: 'opRepeatVec2Limited',
+        type: 'vec2',
+        inputs: [
+                { name: 'p', type: 'vec2' },
+                { name: 'lima', type: 'vec2' },
+                { name: 'limb', type: 'vec2' },
+                { name: 's', type: 'float' }
+        ]
+})
+
+export const opRepeatVec3Limited = Fn(([p, lima, limb, s]: [Vec3, Vec3, Vec3, Float]): Vec3 => {
+        return p.sub(s.mul(p.div(s).floor().clamp(lima, limb)))
+}).setLayout({
+        name: 'opRepeatVec3Limited',
+        type: 'vec3',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'lima', type: 'vec3' },
+                { name: 'limb', type: 'vec3' },
+                { name: 's', type: 'float' }
+        ]
+})

package/src/addons/sdf/opRevolve.ts

@@ -0,0 +1,12 @@
+import { Fn, Vec3, Vec2, Float, vec2 } from '../../node'
+
+export const opRevolve = Fn(([p, w]: [Vec3, Float]): Vec2 => {
+        return vec2(vec2(p.x, p.z).length().sub(w), p.y)
+}).setLayout({
+        name: 'opRevolve',
+        type: 'vec2',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'w', type: 'float' },
+        ],
+})

package/src/addons/sdf/opRound.ts

@@ -0,0 +1,12 @@
+import { Fn, Float } from '../../node'
+
+export const opRound = Fn(([d, h]: [Float, Float]): Float => {
+        return d.sub(h)
+}).setLayout({
+        name: 'opRound',
+        type: 'float',
+        inputs: [
+                { name: 'd', type: 'float' },
+                { name: 'h', type: 'float' },
+        ],
+})

package/src/addons/sdf/opSubtraction.ts

@@ -0,0 +1,50 @@
+import { Fn, Float, Vec4, vec4, select } from '../../node'
+
+export const opSubtraction = Fn(([d1, d2]: [Float, Float]): Float => {
+        return d1.negate().max(d2)
+}).setLayout({
+        name: 'opSubtraction',
+        type: 'float',
+        inputs: [
+                { name: 'd1', type: 'float' },
+                { name: 'd2', type: 'float' }
+        ]
+})
+
+export const opSubtractionVec4 = Fn(([d1, d2]: [Vec4, Vec4]): Vec4 => {
+        return d1.negate().select(d2, d1.w.negate().greaterThan(d2.w))
+}).setLayout({
+        name: 'opSubtractionVec4',
+        type: 'vec4',
+        inputs: [
+                { name: 'd1', type: 'vec4' },
+                { name: 'd2', type: 'vec4' }
+        ]
+})
+
+export const opSubtractionSmooth = Fn(([d1, d2, k]: [Float, Float, Float]): Float => {
+        const h = d2.add(d1).div(k).mul(0.5).sub(0.5).negate().clamp(0, 1).toVar('h')
+        return d2.mix(d1.negate(), h).add(k.mul(h).mul(h.oneMinus()))
+}).setLayout({
+        name: 'opSubtractionSmooth',
+        type: 'float',
+        inputs: [
+                { name: 'd1', type: 'float' },
+                { name: 'd2', type: 'float' },
+                { name: 'k', type: 'float' }
+        ]
+})
+
+export const opSubtractionSmoothVec4 = Fn(([d1, d2, k]: [Vec4, Vec4, Float]): Vec4 => {
+        const h = d2.w.add(d1.w).div(k).mul(0.5).sub(0.5).negate().clamp(0, 1).toVar('h')
+        const result = d2.mix(d1.negate(), h).toVar('result')
+        return vec4(result.xyz, result.w.add(k.mul(h).mul(h.oneMinus())))
+}).setLayout({
+        name: 'opSubtractionSmoothVec4',
+        type: 'vec4',
+        inputs: [
+                { name: 'd1', type: 'vec4' },
+                { name: 'd2', type: 'vec4' },
+                { name: 'k', type: 'float' }
+        ]
+})

package/src/addons/sdf/opUnion.ts

@@ -0,0 +1,39 @@
+import { Fn, Float, Vec4, vec4 } from '../../node'
+
+export const opUnion = Fn(([d1, d2]: [Float, Float]): Float => {
+        return d1.min(d2)
+}).setLayout({
+        name: 'opUnion',
+        type: 'float',
+        inputs: [
+                { name: 'd1', type: 'float' },
+                { name: 'd2', type: 'float' },
+        ],
+})
+
+export const opUnionSmooth = Fn(([d1, d2, k]: [Float, Float, Float]): Float => {
+        const h = d2.sub(d1).div(k).mul(0.5).add(0.5).clamp(0, 1).toVar('h')
+        return d2.mix(d1, h).sub(k.mul(h).mul(h.oneMinus()))
+}).setLayout({
+        name: 'opUnionSmooth',
+        type: 'float',
+        inputs: [
+                { name: 'd1', type: 'float' },
+                { name: 'd2', type: 'float' },
+                { name: 'k', type: 'float' },
+        ],
+})
+
+export const opUnionSmoothVec4 = Fn(([d1, d2, k]: [Vec4, Vec4, Float]): Vec4 => {
+        const h = d2.w.sub(d1.w).div(k).mul(0.5).add(0.5).clamp(0, 1).toVar('h')
+        const result = d2.mix(d1, h).toVar('result')
+        return vec4(result.xyz, result.w.sub(k.mul(h).mul(h.oneMinus())))
+}).setLayout({
+        name: 'opUnionSmoothVec4',
+        type: 'vec4',
+        inputs: [
+                { name: 'd1', type: 'vec4' },
+                { name: 'd2', type: 'vec4' },
+                { name: 'k', type: 'float' },
+        ],
+})

package/src/addons/sdf/planeSDF.ts

@@ -0,0 +1,21 @@
+import { Fn, Vec3, Float } from '../../node'
+
+export const planeSDF = Fn(([p]: [Vec3]): Float => {
+        return p.y
+}).setLayout({
+        name: 'planeSDF',
+        type: 'float',
+        inputs: [{ name: 'p', type: 'vec3' }],
+})
+
+export const planeSDFNormal = Fn(([p, planePoint, planeNormal]: [Vec3, Vec3, Vec3]): Float => {
+        return planeNormal.dot(p).add(planeNormal.dot(planePoint)).div(planeNormal.length())
+}).setLayout({
+        name: 'planeSDFNormal',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'planePoint', type: 'vec3' },
+                { name: 'planeNormal', type: 'vec3' },
+        ],
+})

package/src/addons/sdf/polySDF.ts

@@ -0,0 +1,32 @@
+import { Fn, Vec2, Float, Int, atan2 } from '../../node'
+import { PI, TAU } from '../math/const'
+
+export const polySDF = Fn(([st, V]: [Vec2, Int]): Float => {
+        const p = st.mul(2).sub(1).toVar('p')
+        const a = atan2(p.y, p.x).add(PI).toVar('a')
+        const r = p.length().toVar('r')
+        const v = TAU.div(V.toFloat()).toVar('v')
+        return a.div(v).add(0.5).floor().mul(v).sub(a).cos().mul(r)
+}).setLayout({
+        name: 'polySDF',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'V', type: 'int' }
+        ]
+})
+
+export const polySDFFloat = Fn(([st, V]: [Vec2, Float]): Float => {
+        const p = st.mul(2).sub(1).toVar('p')
+        const a = atan2(p.y, p.x).add(PI).toVar('a')
+        const r = p.length().toVar('r')
+        const v = TAU.div(V).toVar('v')
+        return a.div(v).add(0.5).floor().mul(v).sub(a).cos().mul(r)
+}).setLayout({
+        name: 'polySDFFloat',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'V', type: 'float' }
+        ]
+})

package/src/addons/sdf/pyramidSDF.ts

@@ -0,0 +1,29 @@
+import { Fn, Vec3, Float, vec3, vec2, select, float } from '../../node'
+
+export const pyramidSDF = Fn(([p, h]: [Vec3, Float]): Float => {
+        const m2 = h.mul(h).add(0.25).toVar('m2')
+        const pxz = vec2(p.x, p.z).abs().toVar('pxz')
+        const pxzSwapped = select(vec2(pxz.y, pxz.x), pxz, pxz.y.greaterThan(pxz.x)).toVar('pxzSwapped')
+        const pxzFinal = pxzSwapped.sub(0.5).toVar('pxzFinal')
+        p.assign(vec3(pxzFinal.x, p.y, pxzFinal.y))
+        const q = vec3(p.z, h.mul(p.y).sub(p.x.mul(0.5)), h.mul(p.x).add(p.y.mul(0.5))).toVar('q')
+        const s = q.x.negate().max(0).toVar('s')
+        const t = q.y.sub(p.z.mul(0.5)).div(m2.add(0.25)).clamp(0, 1).toVar('t')
+        const a = m2.mul(q.x.add(s)).mul(q.x.add(s)).add(q.y.mul(q.y)).toVar('a')
+        const b = m2
+                .mul(q.x.add(t.mul(0.5)))
+                .mul(q.x.add(t.mul(0.5)))
+                .add(q.y.sub(m2.mul(t)).mul(q.y.sub(m2.mul(t))))
+                .toVar('b')
+        const d2 = select(float(0), a.min(b), q.y.min(q.x.negate().mul(m2).sub(q.y.mul(0.5))).greaterThan(0))
+                .toFloat()
+                .toVar('d2')
+        return d2.add(q.z.mul(q.z)).div(m2).sqrt().mul(q.z.max(p.y.negate()).sign())
+}).setLayout({
+        name: 'pyramidSDF',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'h', type: 'float' },
+        ],
+})

package/src/addons/sdf/raysSDF.ts

@@ -0,0 +1,14 @@
+import { Fn, Vec2, Int, Float, atan2 } from '../../node'
+import { TAU } from '../math/const'
+
+export const raysSDF = Fn(([st, N]: [Vec2, Int]): Float => {
+        const centered = st.sub(0.5).toVar('centered')
+        return atan2(centered.y, centered.x).div(TAU).mul(N.toFloat()).fract()
+}).setLayout({
+        name: 'raysSDF',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'N', type: 'int' },
+        ],
+})

package/src/addons/sdf/rhombSDF.ts

@@ -0,0 +1,10 @@
+import { Fn, Vec2, Float, vec2 } from '../../node'
+import { triSDF } from './triSDF'
+
+export const rhombSDF = Fn(([st]: [Vec2]): Float => {
+        return triSDF(st).max(triSDF(vec2(st.x, st.y.oneMinus())))
+}).setLayout({
+        name: 'rhombSDF',
+        type: 'float',
+        inputs: [{ name: 'st', type: 'vec2' }],
+})

package/src/addons/sdf/spiralSDF.ts

@@ -0,0 +1,15 @@
+import { Fn, Vec2, Float, atan2 } from '../../node'
+
+export const spiralSDF = Fn(([st, t]: [Vec2, Float]): Float => {
+        const centeredSt = st.sub(0.5).toVar('centeredSt')
+        const r = centeredSt.dot(centeredSt).toVar('r')
+        const a = atan2(centeredSt.y, centeredSt.x).toVar('a')
+        return r.log().mul(t).add(a.mul(0.159)).fract().sin().abs()
+}).setLayout({
+        name: 'spiralSDF',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 't', type: 'float' },
+        ],
+})