glre 0.38.0 → 0.40.0

package/src/addons/geometry/aabb/centroid.ts

@@ -0,0 +1,10 @@
+import { Fn, Vec3 } from '../../../node'
+import { AABBType } from './aabb'
+
+export const aabbCentroid = Fn(([box]: [AABBType]): Vec3 => {
+        return box.minBounds.add(box.maxBounds).mul(0.5)
+}).setLayout({
+        name: 'aabbCentroid',
+        type: 'vec3',
+        inputs: [{ name: 'box', type: 'auto' }],
+})

package/src/addons/geometry/aabb/contain.ts

@@ -0,0 +1,19 @@
+import { Fn, Vec3, Bool } from '../../../node'
+import { AABBType } from './aabb'
+
+export const aabbContain = Fn(([box, point]: [AABBType, Vec3]): Bool => {
+        return point.x
+                .greaterThan(box.minBounds.x)
+                .and(point.x.lessThanEqual(box.maxBounds.x))
+                .and(point.y.greaterThan(box.minBounds.y))
+                .and(point.y.lessThanEqual(box.maxBounds.y))
+                .and(point.z.greaterThan(box.minBounds.z))
+                .and(point.z.lessThanEqual(box.maxBounds.z))
+}).setLayout({
+        name: 'aabbContain',
+        type: 'bool',
+        inputs: [
+                { name: 'box', type: 'auto' },
+                { name: 'point', type: 'vec3' },
+        ],
+})

package/src/addons/geometry/aabb/diagonal.ts

@@ -0,0 +1,10 @@
+import { Fn, Vec3 } from '../../../node'
+import { AABBType } from './aabb'
+
+export const diagonal = Fn(([box]: [AABBType]): Vec3 => {
+        return box.maxBounds.sub(box.minBounds).abs()
+}).setLayout({
+        name: 'diagonal',
+        type: 'vec3',
+        inputs: [{ name: 'box', type: 'auto' }],
+})

package/src/addons/geometry/aabb/expand.ts

@@ -0,0 +1,16 @@
+import { Fn, Vec3, Float } from '../../../node'
+import { AABBType, AABB } from './aabb'
+
+export const expand = Fn(([box, value]: [AABBType, Float]): AABBType => {
+        return AABB({
+                minBounds: box.minBounds.sub(value),
+                maxBounds: box.maxBounds.add(value),
+        })
+}).setLayout({
+        name: 'expand',
+        type: 'auto',
+        inputs: [
+                { name: 'box', type: 'auto' },
+                { name: 'value', type: 'float' },
+        ],
+})

package/src/addons/geometry/aabb/index.ts

@@ -0,0 +1,7 @@
+export * from './aabb'
+export * from './centroid'
+export * from './contain'
+export * from './diagonal'
+export * from './expand'
+export * from './intersect'
+export * from './square'

package/src/addons/geometry/aabb/intersect.ts

@@ -0,0 +1,20 @@
+import { Fn, Vec3, Vec2, vec2 } from '../../../node'
+import { AABBType } from './aabb'
+
+export const aabbIntersect = Fn(([box, rayOrigin, rayDir]: [AABBType, Vec3, Vec3]): Vec2 => {
+        const tMin = box.minBounds.sub(rayOrigin).div(rayDir)
+        const tMax = box.maxBounds.sub(rayOrigin).div(rayDir)
+        const t1 = tMin.min(tMax)
+        const t2 = tMin.max(tMax)
+        const tNear = t1.x.max(t1.y).max(t1.z)
+        const tFar = t2.x.min(t2.y).min(t2.z)
+        return vec2(tNear, tFar)
+}).setLayout({
+        name: 'aabbIntersect',
+        type: 'vec2',
+        inputs: [
+                { name: 'box', type: 'auto' },
+                { name: 'rayOrigin', type: 'vec3' },
+                { name: 'rayDir', type: 'vec3' },
+        ],
+})

package/src/addons/geometry/aabb/square.ts

@@ -0,0 +1,17 @@
+import { Fn, Float, Vec3, max, abs } from '../../../node'
+import { AABBType, AABB } from './aabb'
+import { diagonal } from './diagonal'
+
+export const square = Fn(([box]: [AABBType]): AABBType => {
+        const diag = diagonal(box).mul(0.5).toVar('diag')
+        const center = box.minBounds.add(diag).toVar('center')
+        const maxDim = max(abs(diag.x), max(abs(diag.y), abs(diag.z))).toVar('maxDim')
+        return AABB({
+                minBounds: center.sub(maxDim),
+                maxBounds: center.add(maxDim),
+        })
+}).setLayout({
+        name: 'square',
+        type: 'auto',
+        inputs: [{ name: 'box', type: 'auto' }],
+})

package/src/addons/geometry/index.ts

@@ -0,0 +1,2 @@
+export * from './aabb'
+export * from './triangle'

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

@@ -0,0 +1,10 @@
+import { Fn, Float, length, cross } from '../../../node'
+import { TriangleType } from './triangle'
+
+export const area = Fn(([tri]: [TriangleType]): Float => {
+        return length(cross(tri.b.sub(tri.a), tri.c.sub(tri.a))).mul(0.5)
+}).setLayout({
+        name: 'area',
+        type: 'float',
+        inputs: [{ name: 'tri', type: 'auto' }],
+})

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

@@ -0,0 +1,50 @@
+import { Fn, Vec3, length, cross, dot, vec3, float } from '../../../node'
+import { area } from './area'
+import { TriangleType } from './triangle'
+
+export const barycentricFromVec3 = Fn(([a, b, c]: [Vec3, Vec3, Vec3]): Vec3 => {
+        const daa = dot(a, a).toVar('daa')
+        const dab = dot(a, b).toVar('dab')
+        const dbb = dot(b, b).toVar('dbb')
+        const dca = dot(c, a).toVar('dca')
+        const dcb = dot(c, b).toVar('dcb')
+        const denom = daa.mul(dbb).sub(dab.mul(dab)).toVar('denom')
+        const y = dbb.mul(dca).sub(dab.mul(dcb)).div(denom).toVar('y')
+        const z = daa.mul(dcb).sub(dab.mul(dca)).div(denom).toVar('z')
+        return vec3(float(1).sub(y).sub(z), y, z)
+}).setLayout({
+        name: 'barycentricFromVec3',
+        type: 'vec3',
+        inputs: [
+                { name: 'a', type: 'vec3' },
+                { name: 'b', type: 'vec3' },
+                { name: 'c', type: 'vec3' },
+        ],
+})
+
+// barycentric(Triangle tri) - Triangle structから座標計算
+export const barycentric = Fn(([tri]: [TriangleType]): Vec3 => {
+        return barycentricFromVec3(tri.a, tri.b, tri.c)
+}).setLayout({
+        name: 'barycentric',
+        type: 'vec3',
+        inputs: [{ name: 'tri', type: 'auto' }],
+})
+
+export const barycentricFromPosition = Fn(([tri, pos]: [TriangleType, Vec3]): Vec3 => {
+        const a = tri.a
+        const b = tri.b
+        const c = tri.c
+        const f0 = a.sub(pos).toVar('f0')
+        const f1 = b.sub(pos).toVar('f1')
+        const f2 = c.sub(pos).toVar('f2')
+        const areaValue = area(tri).toVar('area')
+        return vec3(length(cross(f1, f2)), length(cross(f2, f0)), length(cross(f0, f1))).div(areaValue)
+}).setLayout({
+        name: 'barycentricFromPosition',
+        type: 'vec3',
+        inputs: [
+                { name: 'tri', type: 'auto' },
+                { name: 'pos', type: 'vec3' },
+        ],
+})

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

@@ -0,0 +1,10 @@
+import { Fn, Vec3 } from '../../../node'
+import { TriangleType } from './triangle'
+
+export const triangleCentroid = Fn(([tri]: [TriangleType]): Vec3 => {
+        return tri.a.add(tri.b).add(tri.c).div(3)
+}).setLayout({
+        name: 'triangleCentroid',
+        type: 'vec3',
+        inputs: [{ name: 'tri', type: 'auto' }],
+})

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

@@ -0,0 +1,85 @@
+import { Fn, Vec3, dot, length, cross, normalize, max, min, vec3, float, If, Return } from '../../../node'
+import { barycentricFromVec3 } from './barycentric'
+import { TriangleType } from './triangle'
+
+export const closestPointWithNormal = Fn(([tri, triNormal, pos]: [TriangleType, Vec3, Vec3]): Vec3 => {
+        const a = tri.a
+        const b = tri.b
+        const c = tri.c
+        const ab = b.sub(a)
+        const ac = c.sub(a)
+        const p = pos.sub(dot(triNormal, pos.sub(a)).mul(triNormal))
+        const ap = p.sub(a)
+        const bcoords = barycentricFromVec3(ab, ac, ap)
+
+        If(bcoords.x.lessThan(0), () => {
+                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)))
+        })
+
+        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)))
+        })
+
+        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.mul(bcoords.x).add(b.mul(bcoords.y)).add(c.mul(bcoords.z))
+}).setLayout({
+        name: 'closestPointWithNormal',
+        type: 'vec3',
+        inputs: [
+                { name: 'tri', type: 'auto' },
+                { name: 'triNormal', type: 'vec3' },
+                { name: 'pos', type: 'vec3' },
+        ],
+})
+
+export const closestPoint = Fn(([tri, pos]: [TriangleType, Vec3]): Vec3 => {
+        const a = tri.a
+        const b = tri.b
+        const c = tri.c
+        const ab = b.sub(a) // .toVar('ab') @TODO FIX
+        const ac = c.sub(a)
+        const normal = normalize(cross(ac, ab))
+        const p = pos.sub(dot(normal, pos.sub(a)).mul(normal))
+        const ap = p.sub(a)
+        const bcoords = barycentricFromVec3(ab, ac, ap)
+
+        If(bcoords.x.lessThan(0), () => {
+                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)))
+        })
+
+        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)))
+        })
+
+        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.mul(bcoords.x).add(b.mul(bcoords.y)).add(c.mul(bcoords.z))
+}).setLayout({
+        name: 'closestPoint',
+        type: 'vec3',
+        inputs: [
+                { name: 'tri', type: 'auto' },
+                { name: 'pos', type: 'vec3' },
+        ],
+})

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

@@ -0,0 +1,19 @@
+import { Fn, Bool, Vec3, cross, dot } from '../../../node'
+import { TriangleType } from './triangle'
+
+export const triangleContain = Fn(([tri, pos]: [TriangleType, Vec3]): Bool => {
+        const localA = tri.a.sub(pos).toVar('localA')
+        const localB = tri.b.sub(pos).toVar('localB')
+        const localC = tri.c.sub(pos).toVar('localC')
+        const u = cross(localB, localC).toVar('u')
+        const v = cross(localC, localA).toVar('v')
+        const w = cross(localA, localB).toVar('w')
+        return dot(u, v).greaterThanEqual(0).and(dot(u, w).greaterThanEqual(0))
+}).setLayout({
+        name: 'triangleContain',
+        type: 'bool',
+        inputs: [
+                { name: 'tri', type: 'auto' },
+                { name: 'pos', type: 'vec3' },
+        ],
+})

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

@@ -0,0 +1,38 @@
+import { Fn, Float, Vec3, cross, dot, sign, sqrt, min } from '../../../node'
+import { lengthSq } from '../../math/lengthSq'
+import { TriangleType } from './triangle'
+
+export const distanceSq = Fn(([tri, pos]: [TriangleType, Vec3]): Float => {
+        const a = tri.a
+        const b = tri.b
+        const c = tri.c
+        const v21 = b.sub(a)
+        const p1 = pos.sub(a)
+        const v32 = c.sub(b)
+        const p2 = pos.sub(b)
+        const v13 = a.sub(c)
+        const p3 = pos.sub(c)
+        const nor = cross(v21, v13)
+
+        const s1 = sign(dot(cross(v21, nor), p1))
+        const s2 = sign(dot(cross(v32, nor), p2))
+        const s3 = sign(dot(cross(v13, nor), p3))
+        const signSum = s1.add(s2).add(s3)
+
+        const edge1 = lengthSq(v21.mul(dot(v21, p1).div(lengthSq(v21)).saturate()).sub(p1))
+        const edge2 = lengthSq(v32.mul(dot(v32, p2).div(lengthSq(v32)).saturate()).sub(p2))
+        const edge3 = lengthSq(v13.mul(dot(v13, p3).div(lengthSq(v13)).saturate()).sub(p3))
+        const edgeDistance = min(min(edge1, edge2), edge3)
+
+        const planeDistance = dot(nor, p1).mul(dot(nor, p1)).div(lengthSq(nor))
+
+        // @ts-ignore
+        return sqrt(edgeDistance.select(planeDistance, signSum.lessThan(2))) as Float
+}).setLayout({
+        name: 'distanceSq',
+        type: 'float',
+        inputs: [
+                { name: 'tri', type: 'auto' },
+                { name: 'pos', type: 'vec3' },
+        ],
+})

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

@@ -0,0 +1,10 @@
+export * from './area'
+export * from './barycentric'
+export * from './centroid'
+export * from './closestPoint'
+export * from './contain'
+export * from './distanceSq'
+export * from './intersect'
+export * from './normal'
+export * from './signedDistance'
+export * from './triangle'

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

@@ -0,0 +1,49 @@
+import { Fn, Float, Vec3, cross, dot, float, struct, vec3 } from '../../../node'
+import { TriangleType } from './triangle'
+
+export const Ray = struct({
+        origin: vec3(),
+        direction: vec3(),
+})
+
+export type RayType = ReturnType<typeof Ray>
+
+export const triangleIntersect = Fn(([tri, rayOrigin, rayDir]: [TriangleType, Vec3, Vec3]): Float => {
+        const v1v0 = tri.b.sub(tri.a)
+        const v2v0 = tri.c.sub(tri.a)
+        const rov0 = rayOrigin.sub(tri.a)
+        const point = cross(v1v0, v2v0)
+        const q = cross(rov0, rayDir)
+        const d = float(1).div(dot(rayDir, point))
+        const u = d.mul(dot(q, v2v0).negate())
+        const v = d.mul(dot(q, v1v0))
+        const t = d.mul(dot(point, rov0).negate())
+
+        const isOutside = u
+                .lessThan(0)
+                .or(u.greaterThan(1))
+                .or(v.lessThan(0))
+                .or(u.add(v).greaterThan(1))
+                .or(t.lessThan(0))
+
+        return float(9999999.9).select(t, isOutside)
+}).setLayout({
+        name: 'triangleIntersect',
+        type: 'float',
+        inputs: [
+                { name: 'tri', type: 'auto' },
+                { name: 'rayOrigin', type: 'vec3' },
+                { name: 'rayDir', type: 'vec3' },
+        ],
+})
+
+export const triangleIntersectRay = Fn(([tri, ray]: [TriangleType, RayType]): Float => {
+        return triangleIntersect(tri, ray.origin, ray.direction)
+}).setLayout({
+        name: 'triangleIntersectRay',
+        type: 'float',
+        inputs: [
+                { name: 'tri', type: 'auto' },
+                { name: 'ray', type: 'auto' },
+        ],
+})

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

@@ -0,0 +1,12 @@
+import { Fn, Vec3, cross, normalize } from '../../../node'
+import { TriangleType } from './triangle'
+
+export const normal = Fn(([tri]: [TriangleType]): Vec3 => {
+        return normalize(cross(tri.b.sub(tri.a), tri.c.sub(tri.a)))
+}).setLayout({
+        name: 'normal',
+        type: 'vec3',
+        inputs: [
+                { name: 'tri', type: 'auto' },
+        ],
+})

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

@@ -0,0 +1,31 @@
+import { Fn, Float, Vec3, length, sign, dot } from '../../../node'
+import { normal } from './normal'
+import { closestPointWithNormal } from './closestPoint'
+import { TriangleType } from './triangle'
+
+export const signedDistanceWithNormal = Fn(([tri, triNormal, pos]: [TriangleType, Vec3, Vec3]): Float => {
+        const nearest = closestPointWithNormal(tri, triNormal, pos).toVar('nearest')
+        const delta = pos.sub(nearest).toVar('delta')
+        const distance = length(delta).toVar('distance')
+        return distance.mul(sign(dot(delta.div(distance), triNormal)))
+}).setLayout({
+        name: 'signedDistanceWithNormal',
+        type: 'float',
+        inputs: [
+                { name: 'tri', type: 'auto' },
+                { name: 'triNormal', type: 'vec3' },
+                { name: 'pos', type: 'vec3' },
+        ],
+})
+
+export const signedDistance = Fn(([tri, pos]: [TriangleType, Vec3]): Float => {
+        const triNormal = normal(tri).toVar('triNormal')
+        return signedDistanceWithNormal(tri, triNormal, pos)
+}).setLayout({
+        name: 'signedDistance',
+        type: 'float',
+        inputs: [
+                { name: 'tri', type: 'auto' },
+                { name: 'pos', type: 'vec3' },
+        ],
+})

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

@@ -0,0 +1,9 @@
+import { struct, vec3 } from '../../../node'
+
+export const Triangle = struct({
+        a: vec3(),
+        b: vec3(),
+        c: vec3(),
+})
+
+export type TriangleType = ReturnType<typeof Triangle>

package/src/addons/index.ts

@@ -0,0 +1,8 @@
+export * from './animation/easing'
+export * from './color/space'
+export * from './draw'
+export * from './geometry'
+export * from './generative'
+export * from './math'
+export * from './sdf'
+export * from './space'

package/src/addons/lighting/ray.ts

@@ -0,0 +1,8 @@
+import { struct, vec3 } from '../../node'
+
+export const Ray = struct({
+        origin: vec3(),
+        direction: vec3(),
+})
+
+export type RayType = ReturnType<typeof Ray>

package/src/addons/math/aafloor.ts

@@ -0,0 +1,13 @@
+import { Fn, X, dFdx, dFdy, fract, float, select } from '../../node'
+import { mapRange } from './map'
+
+export const aafloor = Fn(([x]: [X]): X => {
+        const afwidth = dFdx(x).pow(2).add(dFdy(x).pow(2)).sqrt().mul(2).toVar()
+        const fx = fract(x).toVar()
+        const idx = afwidth.oneMinus().toVar()
+        return select(x.sub(fx), mapRange(fx, idx, float(1), x.sub(fx), x), fx.lessThan(idx))
+}).setLayout({
+        name: 'aafloor',
+        type: 'auto',
+        inputs: [{ name: 'x', type: 'auto' }],
+})

package/src/addons/math/aafract.ts

@@ -0,0 +1,38 @@
+import { Fn, Float, Vec2, X, dFdx, dFdy, fract, length, mix, smoothstep, vec2, select, float } from '../../node'
+
+const nyquist = Fn(([x, width]: [Float, Float]): Float => {
+        const cutoffStart = float(0.25).toVar('cutoffStart') // NYQUIST_FILTER_CENTER - NYQUIST_FILTER_WIDTH
+        const cutoffEnd = float(0.75).toVar('cutoffEnd') // NYQUIST_FILTER_CENTER + NYQUIST_FILTER_WIDTH
+        const f = smoothstep(cutoffEnd, cutoffStart, width).toVar('f')
+        return mix(float(0.5), x, f)
+}).setLayout({
+        name: 'nyquist',
+        type: 'float',
+        inputs: [
+                { name: 'x', type: 'float' },
+                { name: 'width', type: 'float' },
+        ],
+})
+
+export const aafract = Fn(([x]: [X]): X => {
+        const afwidth = length(vec2(dFdx(x), dFdy(x)))
+                .mul(2)
+                .toVar('afwidth')
+        const fx = fract(x).toVar('fx')
+        const idx = afwidth.oneMinus().toVar('idx')
+        const v = select(fx.div(idx as any), fx.oneMinus().div(afwidth as any), fx.lessThan(idx as any)).toVar('v')
+        return nyquist(v as any, afwidth as any)
+}).setLayout({
+        name: 'aafract',
+        type: 'auto',
+        inputs: [{ name: 'x', type: 'auto' }],
+})
+
+// Vector overloads
+export const aafractVec2 = Fn(([v]: [Vec2]): Vec2 => {
+        return vec2(aafract(v.x), aafract(v.y))
+}).setLayout({
+        name: 'aafractVec2',
+        type: 'vec2',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})

package/src/addons/math/aamirror.ts

@@ -0,0 +1,12 @@
+import { Fn, Float, X, dFdx, dFdy, length, vec2, floor, abs } from '../../node'
+import { nyquist } from './nyquist'
+
+export const aamirror = Fn(([x]: [X]): X => {
+        const afwidth = length(vec2(dFdx(x), dFdy(x)))
+        const v = abs(x.sub(floor(x.add(0.5)))).mul(2)
+        return nyquist(v, afwidth)
+}).setLayout({
+        name: 'aamirror',
+        type: 'auto',
+        inputs: [{ name: 'x', type: 'auto' }],
+})

package/src/addons/math/aastep.ts

@@ -0,0 +1,14 @@
+import { Fn, Float, length, vec2, dFdx, dFdy, smoothstep } from '../../node'
+
+export const aastep = Fn(([threshold, value]: [Float, Float]): Float => {
+        const derivative = vec2(dFdx(value), dFdy(value))
+        const afwidth = length(derivative).mul(0.7)
+        return smoothstep(threshold.sub(afwidth), threshold.add(afwidth), value)
+}).setLayout({
+        name: 'aastep',
+        type: 'float',
+        inputs: [
+                { name: 'threshold', type: 'float' },
+                { name: 'value', type: 'float' },
+        ],
+})

package/src/addons/math/absi.ts

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

package/src/addons/math/adaptiveThreshold.ts

@@ -0,0 +1,24 @@
+import { Fn, Float, step } from '../../node'
+
+export const adaptiveThreshold = Fn(([v, blur_v, b]: [Float, Float, Float]): Float => {
+        return step(blur_v.add(b), v)
+}).setLayout({
+        name: 'adaptiveThreshold',
+        type: 'float',
+        inputs: [
+                { name: 'v', type: 'float' },
+                { name: 'blur_v', type: 'float' },
+                { name: 'b', type: 'float' },
+        ],
+})
+
+export const adaptiveThresholdSimple = Fn(([v, blur_v]: [Float, Float]): Float => {
+        return step(blur_v.sub(0.05), v)
+}).setLayout({
+        name: 'adaptiveThresholdSimple',
+        type: 'float',
+        inputs: [
+                { name: 'v', type: 'float' },
+                { name: 'blur_v', type: 'float' },
+        ],
+})

package/src/addons/math/bump.ts

@@ -0,0 +1,20 @@
+import { Fn, X } from '../../node'
+
+export const bump = Fn(([x, k]: [X, X]): X => {
+        return x.mul(x).sub(1).negate().sub(k).saturate()
+}).setLayout({
+        name: 'bump',
+        type: 'auto',
+        inputs: [
+                { name: 'x', type: 'auto' },
+                { name: 'k', type: 'auto' },
+        ],
+})
+
+export const bumpSimple = Fn(([x]: [X]): X => {
+        return x.mul(x).sub(1).negate().max(0)
+}).setLayout({
+        name: 'bumpSimple',
+        type: 'auto',
+        inputs: [{ name: 'x', type: 'auto' }],
+})

package/src/addons/math/const.ts

@@ -0,0 +1,19 @@
+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 INV_PI = float(0.31830988618379067153776752674503)
+export const INV_SQRT_TAU = float(0.39894228040143267793994605993439)
+export const SQRT_HALF_PI = float(1.25331413732)
+export const PHI = float(1.618033988749894848204586834)
+export const EPSILON = float(0.00001)
+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)