glre 0.41.0 → 0.43.0

package/src/addons/math/rotate3dY.ts

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

package/src/addons/math/rotate3dZ.ts

@@ -3,18 +3,9 @@ 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)
-        )
+        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'
-                }
-        ]
-})
+        inputs: [{ name: 'r', type: 'float' }],
+})

package/src/addons/math/rotate4d.ts

@@ -29,13 +29,7 @@ export const rotate4d = Fn(([a, r]: [Vec3, Float]): Mat4 => {
         name: 'rotate4d',
         type: 'mat4',
         inputs: [
-                {
-                        name: 'a',
-                        type: 'vec3'
-                },
-                {
-                        name: 'r',
-                        type: 'float'
-                }
-        ]
-})
+                { name: 'a', type: 'vec3' },
+                { name: 'r', type: 'float' },
+        ],
+})

package/src/addons/math/rotate4dX.ts

@@ -3,19 +3,9 @@ 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)
-        )
+        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'
-                }
-        ]
-})
+        inputs: [{ name: 'r', type: 'float' }],
+})

package/src/addons/math/rotate4dY.ts

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

package/src/addons/math/rotate4dZ.ts

@@ -3,19 +3,9 @@ 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)
-        )
+        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'
-                }
-        ]
-})
+        inputs: [{ name: 'r', type: 'float' }],
+})

package/src/addons/math/scale2d.ts

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

package/src/addons/math/toMat3.ts

@@ -5,10 +5,5 @@ export const toMat3 = Fn(([m]: [Mat4]): Mat3 => {
 }).setLayout({
         name: 'toMat3',
         type: 'mat3',
-        inputs: [
-                {
-                        name: 'm',
-                        type: 'mat4',
-                },
-        ],
+        inputs: [{ name: 'm', type: 'mat4' }],
 })

package/src/addons/math/toMat4.ts

@@ -5,10 +5,5 @@ export const toMat4 = Fn(([m]: [Mat3]): Mat4 => {
 }).setLayout({
         name: 'toMat4',
         type: 'mat4',
-        inputs: [
-                {
-                        name: 'm',
-                        type: 'mat3',
-                },
-        ],
+        inputs: [{ name: 'm', type: 'mat3' }],
 })

package/src/addons/sdf/arrowSDF.ts

@@ -0,0 +1,61 @@
+import { Fn, Vec3, Float, vec3, vec2, mat3, float, If } from '../../node'
+
+export const arrowSDF = Fn(
+        ([v, start, end, baseRadius, tipRadius, tipHeight]: [Vec3, Vec3, Vec3, Float, Float, Float]): Float => {
+                const t = start.sub(end).toVar('t')
+                const l = t.length().toVar('l')
+                t.assign(t.div(l))
+                l.assign(l.max(tipHeight))
+                v.assign(v.sub(end))
+
+                If(t.y.add(1).lessThan(0.0001), () => {
+                        v.assign(vec3(v.x, v.y.negate(), v.z))
+                }).Else(() => {
+                        const k = float(1).div(float(1).add(t.y)).toVar('k')
+                        const column1 = vec3(t.z.mul(t.z).mul(k).add(t.y), t.x, t.z.mul(t.x.negate()).mul(k)).toVar(
+                                'column1'
+                        )
+                        const column2 = vec3(t.x.negate(), t.y, t.z.negate()).toVar('column2')
+                        const column3 = vec3(t.x.negate().mul(t.z).mul(k), t.z, t.x.mul(t.x).mul(k).add(t.y)).toVar(
+                                'column3'
+                        )
+                        v.assign(
+                                mat3(
+                                        column1.x,
+                                        column1.y,
+                                        column1.z,
+                                        column2.x,
+                                        column2.y,
+                                        column2.z,
+                                        column3.x,
+                                        column3.y,
+                                        column3.z
+                                ).mul(v)
+                        )
+                })
+
+                const q = vec2(vec2(v.x, v.z).length(), v.y).toVar('q')
+                q.assign(vec2(q.x.abs(), q.y))
+                const e = vec2(tipRadius, tipHeight).toVar('e')
+                const h = q.dot(e).div(e.dot(e)).clamp(0, 1).toVar('h')
+                const d1 = q.sub(e.mul(h)).toVar('d1')
+                const d2 = q.sub(vec2(tipRadius, tipHeight)).toVar('d2')
+                d2.assign(vec2(d2.x.sub(d2.x.clamp(baseRadius.sub(tipRadius), 0)), d2.y))
+                const d3 = q.sub(vec2(baseRadius, tipHeight)).toVar('d3')
+                d3.assign(vec2(d3.x, d3.y.sub(d3.y.clamp(0, l.sub(tipHeight)))))
+                const d4 = vec2(q.y.sub(l), q.x.sub(baseRadius).max(0)).toVar('d4')
+                const s = d1.x.max(d1.y.negate()).max(d4.x).max(d2.y.min(d3.x)).toVar('s')
+                return d1.dot(d1).min(d2.dot(d2)).min(d3.dot(d3)).min(d4.dot(d4)).sqrt().mul(s.sign())
+        }
+).setLayout({
+        name: 'arrowSDF',
+        type: 'float',
+        inputs: [
+                { name: 'v', type: 'vec3' },
+                { name: 'start', type: 'vec3' },
+                { name: 'end', type: 'vec3' },
+                { name: 'baseRadius', type: 'float' },
+                { name: 'tipRadius', type: 'float' },
+                { name: 'tipHeight', type: 'float' },
+        ],
+})

package/src/addons/sdf/boxFrameSDF.ts

@@ -0,0 +1,31 @@
+import { Fn, Vec3, Float, vec3 } from '../../node'
+
+export const boxFrameSDF = Fn(([p, b, e]: [Vec3, Vec3, Float]): Float => {
+        const p_abs = p.abs().sub(b).toVar('p_abs')
+        const q = p_abs.add(e).abs().sub(e).toVar('q')
+
+        const term1 = vec3(p_abs.x, q.y, q.z)
+                .max(vec3(0))
+                .length()
+                .add(p_abs.x.max(q.y.max(q.z)).min(0))
+
+        const term2 = vec3(q.x, p_abs.y, q.z)
+                .max(vec3(0))
+                .length()
+                .add(q.x.max(p_abs.y.max(q.z)).min(0))
+
+        const term3 = vec3(q.x, q.y, p_abs.z)
+                .max(vec3(0))
+                .length()
+                .add(q.x.max(q.y.max(p_abs.z)).min(0))
+
+        return term1.min(term2).min(term3)
+}).setLayout({
+        name: 'boxFrameSDF',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'b', type: 'vec3' },
+                { name: 'e', type: 'float' },
+        ],
+})

package/src/addons/sdf/boxSDF.ts

@@ -6,9 +6,7 @@ export const boxSDF = Fn(([p]: [Vec3]) => {
 }).setLayout({
         name: 'boxSDF',
         type: 'float',
-        inputs: [
-                { name: 'p', type: 'vec3' }
-        ]
+        inputs: [{ name: 'p', type: 'vec3' }],
 })
 
 export const boxSDFSize = Fn(([p, b]: [Vec3, Vec3]) => {
@@ -19,6 +17,6 @@ export const boxSDFSize = Fn(([p, b]: [Vec3, Vec3]) => {
         type: 'float',
         inputs: [
                 { name: 'p', type: 'vec3' },
-                { name: 'b', type: 'vec3' }
-        ]
-})
+                { name: 'b', type: 'vec3' },
+        ],
+})

package/src/addons/sdf/capsuleSDF.ts

@@ -0,0 +1,17 @@
+import { Fn, Vec3, Float } from '../../node'
+
+export const capsuleSDF = Fn(([p, a, b, r]: [Vec3, Vec3, Vec3, Float]): Float => {
+        const pa = p.sub(a).toVar('pa')
+        const ba = b.sub(a).toVar('ba')
+        const h = pa.dot(ba).div(ba.dot(ba)).clamp(0, 1).toVar('h')
+        return pa.sub(ba.mul(h)).length().sub(r)
+}).setLayout({
+        name: 'capsuleSDF',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'a', type: 'vec3' },
+                { name: 'b', type: 'vec3' },
+                { name: 'r', type: 'float' },
+        ],
+})

package/src/addons/sdf/coneSDF.ts

@@ -0,0 +1,60 @@
+import { Fn, Vec3, Vec2, Float, vec2, If } from '../../node'
+
+export const coneSDF = Fn(([p, c]: [Vec3, Vec3]): Float => {
+        const q = vec2(vec2(p.x, p.z).length(), p.y).toVar('q')
+        const d1 = q.y.negate().sub(c.z).toVar('d1')
+        const d2 = q.dot(vec2(c.x, c.y)).max(q.y).toVar('d2')
+        return vec2(d1, d2).max(0).length().add(d1.max(d2).min(0))
+}).setLayout({
+        name: 'coneSDF',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'c', type: 'vec3' },
+        ],
+})
+
+export const coneSDFVec2Height = Fn(([p, c, h]: [Vec3, Vec2, Float]): Float => {
+        const q = h.mul(vec2(c.x, c.y.negate())).div(c.y).toVar('q')
+        const w = vec2(vec2(p.x, p.z).length(), p.y).toVar('w')
+        const a = w.sub(q.mul(w.dot(q).div(q.dot(q)).clamp(0, 1))).toVar('a')
+        const b = w.sub(q.mul(vec2(w.x.div(q.x).clamp(0, 1), 1))).toVar('b')
+        const k = q.y.sign().toVar('k')
+        const d = a.dot(a).min(b.dot(b)).toVar('d')
+        const s = k
+                .mul(w.x.mul(q.y).sub(w.y.mul(q.x)))
+                .max(k.mul(w.y.sub(q.y)))
+                .toVar('s')
+        return d.sqrt().mul(s.sign())
+}).setLayout({
+        name: 'coneSDFVec2Height',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'c', type: 'vec2' },
+                { name: 'h', type: 'float' },
+        ],
+})
+
+export const coneSDFRadii = Fn(([p, r1, r2, h]: [Vec3, Float, Float, Float]): Float => {
+        const q = vec2(vec2(p.x, p.z).length(), p.y).toVar('q')
+        const b = r1.sub(r2).div(h).toVar('b')
+        const a = b.mul(b).oneMinus().sqrt().toVar('a')
+        const k = q.dot(vec2(b.negate(), a)).toVar('k')
+        If(k.lessThan(0), () => {
+                return q.length().sub(r1)
+        })
+        If(k.greaterThan(a.mul(h)), () => {
+                return q.sub(vec2(0, h)).length().sub(r2)
+        })
+        return q.dot(vec2(a, b)).sub(r1)
+}).setLayout({
+        name: 'coneSDFRadii',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'r1', type: 'float' },
+                { name: 'r2', type: 'float' },
+                { name: 'h', type: 'float' },
+        ],
+})

package/src/addons/sdf/crossSDF.ts

@@ -3,15 +3,12 @@ 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)
-        )
+        return min(rectSDF(st, size), rectSDF(st, size.yx))
 }).setLayout({
         name: 'crossSDF',
         type: 'float',
         inputs: [
                 { name: 'st', type: 'vec2' },
-                { name: 's', type: 'float' }
-        ]
-})
+                { name: 's', type: 'float' },
+        ],
+})

package/src/addons/sdf/cubeSDF.ts

@@ -0,0 +1,13 @@
+import { Fn, Vec3, Float, vec3 } from '../../node'
+import { boxSDFSize } from './boxSDF'
+
+export const cubeSDF = Fn(([p, s]: [Vec3, Float]): Float => {
+        return boxSDFSize(p, vec3(s))
+}).setLayout({
+        name: 'cubeSDF',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 's', type: 'float' },
+        ],
+})

package/src/addons/sdf/cylinderSDF.ts

@@ -0,0 +1,65 @@
+import { Fn, Vec3, Vec2, Float, vec2, select, float } from '../../node'
+
+export const cylinderSDF = Fn(([p, h]: [Vec3, Vec2]): Float => {
+        const d = vec2(vec2(p.x, p.z).length(), p.y).abs().sub(h).toVar('d')
+        return d.x.max(d.y).min(0).add(d.max(0).length())
+}).setLayout({
+        name: 'cylinderSDF',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'h', type: 'vec2' },
+        ],
+})
+
+export const cylinderSDFHeight = Fn(([p, h]: [Vec3, Float]): Float => {
+        return cylinderSDF(p, vec2(h))
+}).setLayout({
+        name: 'cylinderSDFHeight',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'h', type: 'float' },
+        ],
+})
+
+export const cylinderSDFHeightRadius = Fn(([p, h, r]: [Vec3, Float, Float]): Float => {
+        const d = vec2(vec2(p.x, p.z).length(), p.y).abs().sub(vec2(h, r)).toVar('d')
+        return d.x.max(d.y).min(0).add(d.max(0).length())
+}).setLayout({
+        name: 'cylinderSDFHeightRadius',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'h', type: 'float' },
+                { name: 'r', type: 'float' },
+        ],
+})
+
+export const cylinderSDFCaps = Fn(([p, a, b, r]: [Vec3, Vec3, Vec3, Float]): Float => {
+        const pa = p.sub(a).toVar('pa')
+        const ba = b.sub(a).toVar('ba')
+        const baba = ba.dot(ba).toVar('baba')
+        const paba = pa.dot(ba).toVar('paba')
+        const x = pa.mul(baba).sub(ba.mul(paba)).length().sub(r.mul(baba)).toVar('x')
+        const y = paba.sub(baba.mul(0.5)).abs().sub(baba.mul(0.5)).toVar('y')
+        const x2 = x.mul(x).toVar('x2')
+        const y2 = y.mul(y).mul(baba).toVar('y2')
+        const d = select(
+                select(float(0), x2, x.greaterThan(0)).add(select(float(0), y2, y.greaterThan(0))),
+                x2.min(y2).negate(),
+                x.max(y).lessThan(0)
+        )
+                .toFloat()
+                .toVar('d')
+        return d.sign().mul(d.abs().sqrt()).div(baba)
+}).setLayout({
+        name: 'cylinderSDFCaps',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'a', type: 'vec3' },
+                { name: 'b', type: 'vec3' },
+                { name: 'r', type: 'float' },
+        ],
+})

package/src/addons/sdf/dodecahedronSDF.ts

@@ -0,0 +1,32 @@
+import { Fn, Vec3, Float, vec3 } from '../../node'
+
+const PHI = 1.618033988749894848204586834
+
+export const dodecahedronSDF = Fn(([p]: [Vec3]): Float => {
+        const n = vec3(PHI, 1, 0).normalize().toVar('n')
+        const pAbs = p.abs().toVar('pAbs')
+        const a = pAbs.dot(vec3(n.x, n.y, n.z)).toVar('a')
+        const b = pAbs.dot(vec3(n.z, n.x, n.y)).toVar('b')
+        const c = pAbs.dot(vec3(n.y, n.z, n.x)).toVar('c')
+        return a.max(b).max(c).sub(n.x)
+}).setLayout({
+        name: 'dodecahedronSDF',
+        type: 'float',
+        inputs: [{ name: 'p', type: 'vec3' }],
+})
+
+export const dodecahedronSDFRadius = Fn(([p, radius]: [Vec3, Float]): Float => {
+        const n = vec3(PHI, 1, 0).normalize().toVar('n')
+        const pScaled = p.abs().div(radius).toVar('pScaled')
+        const a = pScaled.dot(vec3(n.x, n.y, n.z)).toVar('a')
+        const b = pScaled.dot(vec3(n.z, n.x, n.y)).toVar('b')
+        const c = pScaled.dot(vec3(n.y, n.z, n.x)).toVar('c')
+        return a.max(b).max(c).sub(n.x).mul(radius)
+}).setLayout({
+        name: 'dodecahedronSDFRadius',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'radius', type: 'float' },
+        ],
+})

package/src/addons/sdf/ellipsoidSDF.ts

@@ -0,0 +1,14 @@
+import { Fn, Vec3, Float } from '../../node'
+
+export const ellipsoidSDF = Fn(([p, r]: [Vec3, Vec3]): Float => {
+        const k0 = p.div(r).length().toVar('k0')
+        const k1 = p.div(r.mul(r)).length().toVar('k1')
+        return k0.mul(k0.sub(1)).div(k1)
+}).setLayout({
+        name: 'ellipsoidSDF',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'r', type: 'vec3' },
+        ],
+})

package/src/addons/sdf/flowerSDF.ts

@@ -0,0 +1,16 @@
+import { Fn, Vec2, Int, Float, atan2 } from '../../node'
+
+export const flowerSDF = Fn(([st, N]: [Vec2, Int]): Float => {
+        const centered = st.sub(0.5).mul(4).toVar('centered')
+        const r = centered.length().mul(2).toVar('r')
+        const a = atan2(centered.y, centered.x).toVar('a')
+        const v = N.toFloat().mul(0.5).toVar('v')
+        return a.mul(v).cos().abs().mul(0.5).add(0.5).div(r).oneMinus()
+}).setLayout({
+        name: 'flowerSDF',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'N', type: 'int' },
+        ],
+})

package/src/addons/sdf/gearSDF.ts

@@ -0,0 +1,22 @@
+import { Fn, Vec2, Float, Int, float } from '../../node'
+import { mapRange } from '../math'
+
+export const gearSDF = Fn(([st, b, N]: [Vec2, Float, Int]): Float => {
+        const e = float(2.71828182845904523536)
+        const stCentered = st.sub(0.5).mul(3).toVar('stCentered')
+        const s = mapRange(b, float(1), float(15), float(0.066), float(0.5)).toVar('s')
+        const d = stCentered.length().sub(s).toVar('d')
+        const omega = b.mul(N.toFloat().mul(stCentered.y.atan2(stCentered.x)).sin()).toVar('omega')
+        const l = e.pow(omega.mul(2)).toVar('l')
+        const hyperTan = l.sub(1).div(l.add(1)).toVar('hyperTan')
+        const r = hyperTan.div(b).toVar('r')
+        return d.add(d.min(r))
+}).setLayout({
+        name: 'gearSDF',
+        type: 'float',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'b', type: 'float' },
+                { name: 'N', type: 'int' },
+        ],
+})

package/src/addons/sdf/heartSDF.ts

@@ -0,0 +1,17 @@
+import { Fn, Vec2, Float, vec2 } from '../../node'
+
+export const heartSDF = Fn(([st]: [Vec2]): Float => {
+        const centered = st.sub(0.5).sub(vec2(0, 0.3)).toVar('centered')
+        const r = centered.length().mul(5).toVar('r')
+        const normalized = centered.normalize().toVar('normalized')
+        const shape = normalized.y
+                .mul(normalized.x.abs().pow(0.67))
+                .div(normalized.y.add(1.5))
+                .sub(normalized.y.mul(2))
+                .add(1.26)
+        return r.sub(shape)
+}).setLayout({
+        name: 'heartSDF',
+        type: 'float',
+        inputs: [{ name: 'st', type: 'vec2' }],
+})

package/src/addons/sdf/hexPrismSDF.ts

@@ -0,0 +1,15 @@
+import { Fn, Vec3, Vec2, Float, vec2 } from '../../node'
+
+export const hexPrismSDF = Fn(([p, h]: [Vec3, Vec2]): Float => {
+        const q = p.abs().toVar('q')
+        const d1 = q.z.sub(h.y).toVar('d1')
+        const d2 = q.x.mul(0.866025).add(q.y.mul(0.5)).max(q.y).sub(h.x).toVar('d2')
+        return vec2(d1, d2).max(0).length().add(d1.max(d2).min(0))
+}).setLayout({
+        name: 'hexPrismSDF',
+        type: 'float',
+        inputs: [
+                { name: 'p', type: 'vec3' },
+                { name: 'h', type: 'vec2' },
+        ],
+})

package/src/addons/sdf/hexSDF.ts

@@ -1,18 +1,11 @@
-import { Fn, Vec2, Float, abs, max, float } from '../../node'
+import { Fn, Vec2, 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))
-	)
+        const transformed = st.mul(2).sub(1).toVar('transformed')
+        transformed.assign(transformed.abs())
+        return transformed.y.abs().max(transformed.x.mul(0.866025).add(transformed.y.mul(0.5)))
 }).setLayout({
-	name: 'hexSDF',
-	type: 'float',
-	inputs: [{ name: 'st', type: 'vec2' }],
-})
+        name: 'hexSDF',
+        type: 'float',
+        inputs: [{ name: 'st', type: 'vec2' }],
+})