glre 0.38.0 → 0.40.0

package/src/addons/sdf/lineSDF.ts

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

package/src/addons/sdf/rectSDF.ts

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

package/src/addons/sdf/sphereSDF.ts

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

package/src/addons/sdf/triSDF.ts

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

package/src/addons/space/aspect.ts

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

package/src/addons/space/bracketing.ts

@@ -0,0 +1,44 @@
+import { Fn, Vec2, Float, mat2, atan2, cos, sin, mod, vec2, float } from '../../node'
+
+const PI = float(3.1415926535897932384626433832795)
+const TWO_PI = float(6.283185307179586476925286766559)
+const BRACKETING_ANGLE_DELTA = PI.div(20.0)
+
+export const bracketingAxis0 = Fn(([dir]: [Vec2]): Vec2 => {
+        const angle = atan2(dir.y, dir.x).add(TWO_PI)
+        const fractional = mod(angle, BRACKETING_ANGLE_DELTA)
+        const angle0 = angle.sub(fractional)
+        return vec2(cos(angle0), sin(angle0))
+}).setLayout({
+        name: 'bracketingAxis0',
+        type: 'vec2',
+        inputs: [{ name: 'dir', type: 'vec2' }],
+})
+
+export const bracketingAxis1 = Fn(([dir]: [Vec2]): Vec2 => {
+        const angle = atan2(dir.y, dir.x).add(TWO_PI)
+        const fractional = mod(angle, BRACKETING_ANGLE_DELTA)
+        const angle0 = angle.sub(fractional)
+        const vAxis0 = vec2(cos(angle0), sin(angle0))
+        const RotateByAngleDelta = mat2(
+                cos(BRACKETING_ANGLE_DELTA),
+                sin(BRACKETING_ANGLE_DELTA),
+                sin(BRACKETING_ANGLE_DELTA).negate(),
+                cos(BRACKETING_ANGLE_DELTA)
+        )
+        return RotateByAngleDelta.mul(vAxis0)
+}).setLayout({
+        name: 'bracketingAxis1',
+        type: 'vec2',
+        inputs: [{ name: 'dir', type: 'vec2' }],
+})
+
+export const bracketingBlend = Fn(([dir]: [Vec2]): Float => {
+        const angle = atan2(dir.y, dir.x).add(TWO_PI)
+        const fractional = mod(angle, BRACKETING_ANGLE_DELTA)
+        return fractional.div(BRACKETING_ANGLE_DELTA)
+}).setLayout({
+        name: 'bracketingBlend',
+        type: 'float',
+        inputs: [{ name: 'dir', type: 'vec2' }],
+})

package/src/addons/space/brickTile.ts

@@ -0,0 +1,44 @@
+import { Fn, Vec2, Vec4, Float, mod, floor, fract } from '../../node'
+import { sqTile } from './sqTile'
+
+export const brickTile = Fn(([t]: [Vec4]): Vec4 => {
+        const result = t.toVar('result')
+        result.x.assign(result.x.add(mod(result.w, 2).mul(0.5)))
+        result.z.assign(floor(result.z.add(result.x)))
+        result.x.assign(fract(result.x))
+        return result
+}).setLayout({
+        name: 'brickTile',
+        type: 'vec4',
+        inputs: [{ name: 't', type: 'vec4' }],
+})
+
+export const brickTileVec2 = Fn(([st]: [Vec2]): Vec4 => {
+        return brickTile(sqTile(st))
+}).setLayout({
+        name: 'brickTileVec2',
+        type: 'vec4',
+        inputs: [{ name: 'st', type: 'vec2' }],
+})
+
+export const brickTileFloat = Fn(([st, s]: [Vec2, Float]): Vec4 => {
+        return brickTileVec2(st.mul(s))
+}).setLayout({
+        name: 'brickTileFloat',
+        type: 'vec4',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 's', type: 'float' },
+        ],
+})
+
+export const brickTileVec2Scale = Fn(([st, s]: [Vec2, Vec2]): Vec4 => {
+        return brickTileVec2(st.mul(s))
+}).setLayout({
+        name: 'brickTileVec2Scale',
+        type: 'vec4',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 's', type: 'vec2' },
+        ],
+})

package/src/addons/space/cart2polar.ts

@@ -0,0 +1,20 @@
+import { Fn, Vec2, Vec3, atan2, length, acos, vec2, vec3 } from '../../node'
+
+export const cart2polar = Fn(([st]: [Vec2]): Vec2 => {
+        return vec2(atan2(st.y, st.x), length(st))
+}).setLayout({
+        name: 'cart2polar',
+        type: 'vec2',
+        inputs: [{ name: 'st', type: 'vec2' }],
+})
+
+export const cart2polar3D = Fn(([st]: [Vec3]): Vec3 => {
+        const r = length(st).toVar('r')
+        const phi = acos(st.z.div(r)).toVar('phi')
+        const theta = atan2(st.y, st.x).toVar('theta')
+        return vec3(r, phi, theta)
+}).setLayout({
+        name: 'cart2polar3D',
+        type: 'vec3',
+        inputs: [{ name: 'st', type: 'vec3' }],
+})

package/src/addons/space/center.ts

@@ -0,0 +1,32 @@
+import { Fn, Float, Vec2, Vec3 } from '../../node'
+
+function center(x: Float): Float
+function center(v: Vec2): Vec2
+function center(v: Vec3): Vec3
+function center(v: any): any {
+        return v.mul(2).sub(1)
+}
+
+export const centerFloat = Fn(([x]: [Float]): Float => {
+        return center(x)
+}).setLayout({
+        name: 'centerFloat',
+        type: 'float',
+        inputs: [{ name: 'x', type: 'float' }],
+})
+
+export const centerVec2 = Fn(([v]: [Vec2]): Vec2 => {
+        return center(v)
+}).setLayout({
+        name: 'centerVec2',
+        type: 'vec2',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})
+
+export const centerVec3 = Fn(([v]: [Vec3]): Vec3 => {
+        return center(v)
+}).setLayout({
+        name: 'centerVec3',
+        type: 'vec3',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})

package/src/addons/space/checkerTile.ts

@@ -0,0 +1,41 @@
+import { Fn, Vec2, Vec4, Float, mod, abs } from '../../node'
+import { sqTile } from './sqTile'
+
+export const checkerTile = Fn(([t]: [Vec4]): Float => {
+        const c = mod(t.zw, 2).toVar('c')
+        return abs(c.x.sub(c.y))
+}).setLayout({
+        name: 'checkerTile',
+        type: 'float',
+        inputs: [{ name: 't', type: 'vec4' }],
+})
+
+export const checkerTileVec2 = Fn(([v]: [Vec2]): Float => {
+        return checkerTile(sqTile(v))
+}).setLayout({
+        name: 'checkerTileVec2',
+        type: 'float',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})
+
+export const checkerTileFloat = Fn(([v, s]: [Vec2, Float]): Float => {
+        return checkerTileVec2(v.mul(s))
+}).setLayout({
+        name: 'checkerTileFloat',
+        type: 'float',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 's', type: 'float' },
+        ],
+})
+
+export const checkerTileVec2Scale = Fn(([v, s]: [Vec2, Vec2]): Float => {
+        return checkerTileVec2(v.mul(s))
+}).setLayout({
+        name: 'checkerTileVec2Scale',
+        type: 'float',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 's', type: 'vec2' },
+        ],
+})

package/src/addons/space/depth2viewZ.ts

@@ -0,0 +1,43 @@
+import { Fn, Float, select } from '../../node'
+
+// Perspective projection version
+export const depth2viewZ = Fn(([depth, near, far]: [Float, Float, Float]): Float => {
+        return near.mul(far).div(far.sub(near).mul(depth).sub(far))
+}).setLayout({
+        name: 'depth2viewZ',
+        type: 'float',
+        inputs: [
+                { name: 'depth', type: 'float' },
+                { name: 'near', type: 'float' },
+                { name: 'far', type: 'float' },
+        ],
+})
+
+// Orthographic projection version
+export const depth2viewZOrthographic = Fn(([depth, near, far]: [Float, Float, Float]): Float => {
+        return depth.mul(near.sub(far)).sub(near)
+}).setLayout({
+        name: 'depth2viewZOrthographic',
+        type: 'float',
+        inputs: [
+                { name: 'depth', type: 'float' },
+                { name: 'near', type: 'float' },
+                { name: 'far', type: 'float' },
+        ],
+})
+
+// Combined version with orthographic flag
+export const depth2viewZCombined = Fn(([depth, near, far, orthographic]: [Float, Float, Float, Float]): Float => {
+        const perspective = near.mul(far).div(far.sub(near).mul(depth).sub(far))
+        const ortho = depth.mul(near.sub(far)).sub(near)
+        return select(ortho, perspective, orthographic.greaterThan(0.5))
+}).setLayout({
+        name: 'depth2viewZCombined',
+        type: 'float',
+        inputs: [
+                { name: 'depth', type: 'float' },
+                { name: 'near', type: 'float' },
+                { name: 'far', type: 'float' },
+                { name: 'orthographic', type: 'float' },
+        ],
+})

package/src/addons/space/displace.ts

@@ -0,0 +1,55 @@
+import { Fn, Vec3, Vec2, X, texture, float, vec3, int, Loop, If } from '../../node'
+import { lookAtBasic } from './lookAt'
+
+const DISPLACE_DEPTH = float(1).constant('DISPLACE_DEPTH')
+const DISPLACE_PRECISION = float(0.01).constant('DISPLACE_PRECISION')
+const DISPLACE_MAX_ITERATIONS = int(120).constant('DISPLACE_MAX_ITERATIONS')
+
+export const displace = Fn(([tex, ro, rd]: [X, Vec3, Vec3]): Vec3 => {
+        const dz = ro.z.sub(DISPLACE_DEPTH).toVar('dz')
+        const t = dz.div(rd.z).toVar('t')
+        const prev = vec3(ro.x.sub(rd.x.mul(t)), ro.y.sub(rd.y.mul(t)), ro.z.sub(rd.z.mul(t))).toVar('prev')
+        const curr = prev.toVar('curr')
+        const lastD = prev.z.toVar('lastD')
+        const hmap = float(0).toVar('hmap')
+        const df = float(0).toVar('df')
+
+        Loop(DISPLACE_MAX_ITERATIONS, () => {
+                prev.assign(curr)
+                curr.assign(prev.add(rd.mul(DISPLACE_PRECISION)))
+                hmap.assign(texture(tex, curr.xy.sub(0.5)).r)
+                df.assign(curr.z.sub(hmap.mul(DISPLACE_DEPTH)))
+
+                If(df.lessThan(0), () => {
+                        const t = lastD.div(df.abs().add(lastD)).toVar('t')
+                        return prev.add(t.mul(curr.sub(prev))).add(vec3(0.5, 0.5, 0))
+                })
+
+                lastD.assign(df)
+        })
+
+        return vec3(0, 0, 1)
+}).setLayout({
+        name: 'displace',
+        type: 'vec3',
+        inputs: [
+                { name: 'tex', type: 'sampler2D' },
+                { name: 'ro', type: 'vec3' },
+                { name: 'rd', type: 'vec3' },
+        ],
+})
+
+export const displaceUV = Fn(([tex, ro, uv]: [X, Vec3, Vec2]): Vec3 => {
+        const rd = lookAtBasic(ro.negate())
+                .mul(vec3(uv.sub(float(0.5)), 1).normalize())
+                .toVar('rd')
+        return displace(tex, ro, rd)
+}).setLayout({
+        name: 'displaceUV',
+        type: 'vec3',
+        inputs: [
+                { name: 'tex', type: 'sampler2D' },
+                { name: 'ro', type: 'vec3' },
+                { name: 'uv', type: 'vec2' },
+        ],
+})

package/src/addons/space/equirect2xyz.ts

@@ -0,0 +1,17 @@
+import { Fn, Vec2, Vec3, vec3, cos, sin, sqrt, float } from '../../node'
+import { PI, TWO_PI } from '../math/const'
+
+export const equirect2xyz = Fn(([uv]: [Vec2]): Vec3 => {
+        const phi = PI.sub(uv.y.mul(PI)).toVar('phi')
+        const theta = uv.x.mul(TWO_PI).toVar('theta')
+        const dir = vec3(cos(theta), 0, sin(theta)).toVar('dir')
+        dir.y.assign(cos(phi))
+        const multiplier = sqrt(float(1).sub(dir.y.mul(dir.y))).toVar('multiplier')
+        dir.x.assign(dir.x.mul(multiplier))
+        dir.z.assign(dir.z.mul(multiplier))
+        return dir
+}).setLayout({
+        name: 'equirect2xyz',
+        type: 'vec3',
+        inputs: [{ name: 'uv', type: 'vec2' }],
+})

package/src/addons/space/eulerView.ts

@@ -0,0 +1,19 @@
+import { Fn, Vec3, Mat4, mat3 } from '../../node'
+import { rotate3dX, rotate3dY, rotate3dZ } from '../math'
+import { translateMat3 } from './translate'
+
+export const eulerView = Fn(([position, euler]: [Vec3, Vec3]): Mat4 => {
+        const rotZ = rotate3dZ(euler.z)
+        const rotX = rotate3dX(euler.x)
+        const rotY = rotate3dY(euler.y)
+        const identity = mat3(1).toVar('identity')
+        const rotation = rotY.mul(rotX).mul(rotZ).mul(identity).toVar('rotation')
+        return translateMat3(rotation, position)
+}).setLayout({
+        name: 'eulerView',
+        type: 'mat4',
+        inputs: [
+                { name: 'position', type: 'vec3' },
+                { name: 'euler', type: 'vec3' },
+        ],
+})

package/src/addons/space/fisheye2xyz.ts

@@ -0,0 +1,18 @@
+import { Fn, Vec2, Vec3, vec3, sqrt, cos, float } from '../../node'
+import { PI } from '../math/const'
+
+export const fisheye2xyz = Fn(([uv]: [Vec2]): Vec3 => {
+        const ndc = uv.mul(2).sub(1).toVar('ndc')
+        const R = sqrt(ndc.x.mul(ndc.x).add(ndc.y.mul(ndc.y))).toVar('R')
+        const dir = vec3(ndc.x.div(R), 0, ndc.y.div(R)).toVar('dir')
+        const phi = R.mul(PI).mul(0.52).toVar('phi')
+        dir.y.assign(cos(phi))
+        const multiplier = sqrt(float(1).sub(dir.y.mul(dir.y))).toVar('multiplier')
+        dir.x.assign(dir.x.mul(multiplier))
+        dir.z.assign(dir.z.mul(multiplier))
+        return dir
+}).setLayout({
+        name: 'fisheye2xyz',
+        type: 'vec3',
+        inputs: [{ name: 'uv', type: 'vec2' }],
+})

package/src/addons/space/flipY.ts

@@ -0,0 +1,25 @@
+import { Fn, Vec2, Vec3, Vec4, vec2, vec3, vec4 } from '../../node'
+
+export const flipYVec2 = Fn(([v]: [Vec2]): Vec2 => {
+        return vec2(v.x, v.y.oneMinus())
+}).setLayout({
+        name: 'flipY',
+        type: 'vec2',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})
+
+export const flipYVec3 = Fn(([v]: [Vec3]): Vec3 => {
+        return vec3(v.x, v.y.oneMinus(), v.z)
+}).setLayout({
+        name: 'flipY',
+        type: 'vec3',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})
+
+export const flipYVec4 = Fn(([v]: [Vec4]): Vec4 => {
+        return vec4(v.x, v.y.oneMinus(), v.z, v.w)
+}).setLayout({
+        name: 'flipY',
+        type: 'vec4',
+        inputs: [{ name: 'v', type: 'vec4' }],
+})

package/src/addons/space/hexTile.ts

@@ -0,0 +1,18 @@
+import { Fn, Vec2, Vec4, vec2, vec4, float, floor, dot, select } from '../../node'
+
+export const hexTile = Fn(([st]: [Vec2]): Vec4 => {
+        const s = vec2(1, 1.7320508).toVar('s')
+        const o = vec2(0.5, 1).toVar('o')
+        const stYX = vec2(st.y, st.x).toVar('stYX')
+        const i = floor(vec4(stYX, stYX.sub(o)).div(vec4(s, s)))
+                .add(0.5)
+                .toVar('i')
+        const f = vec4(stYX.sub(i.xy.mul(s)), stYX.sub(i.zw.add(0.5).mul(s))).toVar('f')
+        const dotXY = dot(f.xy, f.xy)
+        const dotZW = dot(f.zw, f.zw)
+        return select(vec4(f.wz.add(float(0.5)), i.zw.add(o)), vec4(f.yx.add(float(0.5)), i.xy), dotXY.lessThan(dotZW))
+}).setLayout({
+        name: 'hexTile',
+        type: 'vec4',
+        inputs: [{ name: 'st', type: 'vec2' }],
+})

package/src/addons/space/index.ts

@@ -0,0 +1,38 @@
+export * from './aspect'
+export * from './bracketing'
+export * from './brickTile'
+export * from './cart2polar'
+export * from './center'
+export * from './checkerTile'
+export * from './depth2viewZ'
+export * from './displace'
+export * from './equirect2xyz'
+export * from './eulerView'
+export * from './fisheye2xyz'
+export * from './flipY'
+export * from './hexTile'
+export * from './kaleidoscope'
+export * from './linearizeDepth'
+export * from './mirrorTile'
+export * from './nearest'
+export * from './orthographic'
+export * from './parallaxMapping'
+export * from './perspective'
+export * from './lookAt'
+export * from './polar2cart'
+export * from './ratio'
+export * from './sprite'
+export * from './sqTile'
+export * from './tbn'
+export * from './translate'
+export * from './lookAtView'
+export * from './rotate'
+export * from './rotateX'
+export * from './rotateY'
+export * from './rotateZ'
+export * from './unratio'
+export * from './uncenter'
+export * from './viewZ2depth'
+export * from './xyz2equirect'
+export * from './triTile'
+export * from './windmillTile'

package/src/addons/space/kaleidoscope.ts

@@ -0,0 +1,48 @@
+import { Fn, Vec2, Float, vec2, float, length, atan2, floor, min, max, cos, sin } from '../../node'
+
+const TWO_PI = 6.283185307179586
+
+const kaleidoscopeCore = (coord: Vec2, segmentCount: Float, phase: Float) => {
+        const uv = coord.sub(0.5).toVar('uv')
+        const radius = length(uv).toVar('radius')
+        const angle = atan2(uv.y, uv.x).toVar('angle')
+        const segmentAngle = float(TWO_PI).div(segmentCount).toVar('segmentAngle')
+        const adjustedAngle = angle.sub(segmentAngle.mul(floor(angle.div(segmentAngle)))).toVar('adjustedAngle')
+        const finalAngle = min(adjustedAngle, segmentAngle.sub(adjustedAngle)).toVar('finalAngle')
+        const kuv = vec2(cos(finalAngle.add(phase)), sin(finalAngle.add(phase)))
+                .mul(radius)
+                .add(0.5)
+                .toVar('kuv')
+        return max(min(kuv, kuv.mul(-1).add(2)), kuv.negate())
+}
+
+export const kaleidoscope = Fn(([coord, segmentCount, phase]: [Vec2, Float, Float]): Vec2 => {
+        return kaleidoscopeCore(coord, segmentCount, phase)
+}).setLayout({
+        name: 'kaleidoscope',
+        type: 'vec2',
+        inputs: [
+                { name: 'coord', type: 'vec2' },
+                { name: 'segmentCount', type: 'float' },
+                { name: 'phase', type: 'float' },
+        ],
+})
+
+export const kaleidoscopeDefault = Fn(([coord]: [Vec2]): Vec2 => {
+        return kaleidoscopeCore(coord, float(8), float(0))
+}).setLayout({
+        name: 'kaleidoscopeDefault',
+        type: 'vec2',
+        inputs: [{ name: 'coord', type: 'vec2' }],
+})
+
+export const kaleidoscopeCount = Fn(([coord, segmentCount]: [Vec2, Float]): Vec2 => {
+        return kaleidoscopeCore(coord, segmentCount, float(0))
+}).setLayout({
+        name: 'kaleidoscopeCount',
+        type: 'vec2',
+        inputs: [
+                { name: 'coord', type: 'vec2' },
+                { name: 'segmentCount', type: 'float' },
+        ],
+})

package/src/addons/space/linearizeDepth.ts

@@ -0,0 +1,17 @@
+import { Fn, Float } from '../../node'
+
+export const linearizeDepth = Fn(([depth, near, far]: [Float, Float, Float]): Float => {
+        const normalizedDepth = depth.mul(2).sub(1).toVar('normalizedDepth')
+        return near
+                .mul(far)
+                .mul(2)
+                .div(far.add(near).sub(normalizedDepth.mul(far.sub(near))))
+}).setLayout({
+        name: 'linearizeDepth',
+        type: 'float',
+        inputs: [
+                { name: 'depth', type: 'float' },
+                { name: 'near', type: 'float' },
+                { name: 'far', type: 'float' },
+        ],
+})