glre 0.39.0 → 0.41.0

package/src/addons/space/tbn.ts

@@ -0,0 +1,26 @@
+import { Fn, Vec3, Mat3, mat3, normalize, cross } from '../../node'
+
+export const tbn = Fn(([t, b, n]: [Vec3, Vec3, Vec3]): Mat3 => {
+        return mat3(t, b, n)
+}).setLayout({
+        name: 'tbn',
+        type: 'mat3',
+        inputs: [
+                { name: 't', type: 'vec3' },
+                { name: 'b', type: 'vec3' },
+                { name: 'n', type: 'vec3' },
+        ],
+})
+
+export const tbnFromNormal = Fn(([n, up]: [Vec3, Vec3]): Mat3 => {
+        const t = normalize(cross(up, n)).toVar('t')
+        const b = cross(n, t).toVar('b')
+        return tbn(t, b, n)
+}).setLayout({
+        name: 'tbnFromNormal',
+        type: 'mat3',
+        inputs: [
+                { name: 'n', type: 'vec3' },
+                { name: 'up', type: 'vec3' },
+        ],
+})

package/src/addons/space/translate.ts

@@ -0,0 +1,12 @@
+import { Fn, Mat3, Vec3, vec4, mat4 } from '../../node'
+
+export const translateMat3 = Fn(([m, translation]: [Mat3, Vec3]) => {
+        return mat4(vec4(m[0], 0), vec4(m[1], 0), vec4(m[2], 0), vec4(translation, 1))
+}).setLayout({
+        name: 'translateMat3',
+        type: 'mat4',
+        inputs: [
+                { name: 'm', type: 'mat3' },
+                { name: 'translation', type: 'vec3' },
+        ],
+})

package/src/addons/space/triTile.ts

@@ -0,0 +1,32 @@
+import { Fn, Vec2, Vec4, Float, mat2, vec2, vec4, floor, fract, dot } from '../../node'
+
+export const triTile = Fn(([st]: [Vec2]): Vec4 => {
+        const transformed = st.mul(mat2(vec2(1, -1 / 1.7320508), vec2(0, 2 / 1.7320508))).toVar()
+        const f = vec4(transformed, transformed.negate()).toVar()
+        const i = floor(f).toVar()
+        const fFractional = fract(f).toVar()
+
+        const dotXY = dot(fFractional.xy, fFractional.xy)
+        const dotZW = dot(fFractional.zw, fFractional.zw)
+
+        const condition = dotXY.lessThan(dotZW)
+        const trueValue = vec4(fFractional.xy, vec2(2, 1).mul(i.xy))
+        const falseValue = vec4(fFractional.zw, vec2(2, 1).mul(i.zw).add(1).negate())
+
+        return falseValue.select(trueValue, condition)
+}).setLayout({
+        name: 'triTile',
+        type: 'vec4',
+        inputs: [{ name: 'st', type: 'vec2' }],
+})
+
+export const triTileScaled = Fn(([st, scale]: [Vec2, Float]): Vec4 => {
+        return triTile(st.mul(scale))
+}).setLayout({
+        name: 'triTileScaled',
+        type: 'vec4',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'scale', type: 'float' },
+        ],
+})

package/src/addons/space/uncenter.ts

@@ -0,0 +1,32 @@
+import { Fn, Float, Vec2, Vec3 } from '../../node'
+
+function uncenter(x: Float): Float
+function uncenter(v: Vec2): Vec2
+function uncenter(v: Vec3): Vec3
+function uncenter(v: any): any {
+        return v.mul(0.5).add(0.5)
+}
+
+export const uncenterFloat = Fn(([x]: [Float]): Float => {
+        return uncenter(x)
+}).setLayout({
+        name: 'uncenterFloat',
+        type: 'float',
+        inputs: [{ name: 'x', type: 'float' }],
+})
+
+export const uncenterVec2 = Fn(([v]: [Vec2]): Vec2 => {
+        return uncenter(v)
+}).setLayout({
+        name: 'uncenterVec2',
+        type: 'vec2',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})
+
+export const uncenterVec3 = Fn(([v]: [Vec3]): Vec3 => {
+        return uncenter(v)
+}).setLayout({
+        name: 'uncenterVec3',
+        type: 'vec3',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})

package/src/addons/space/unratio.ts

@@ -0,0 +1,12 @@
+import { Fn, Vec2, vec2 } from '../../node'
+
+export const unratio = Fn(([st, s]: [Vec2, Vec2]): Vec2 => {
+        return vec2(st.x, st.y.mul(s.x.div(s.y)).add(s.y.mul(0.5).sub(s.x.mul(0.5)).div(s.y)))
+}).setLayout({
+        name: 'unratio',
+        type: 'vec2',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 's', type: 'vec2' },
+        ],
+})

package/src/addons/space/viewZ2depth.ts

@@ -0,0 +1,25 @@
+import { Fn, Float } from '../../node'
+
+export const viewZ2depth = Fn(([viewZ, near, far]: [Float, Float, Float]): Float => {
+        return viewZ.add(near).mul(far).div(far.sub(near).mul(viewZ))
+}).setLayout({
+        name: 'viewZ2depth',
+        type: 'float',
+        inputs: [
+                { name: 'viewZ', type: 'float' },
+                { name: 'near', type: 'float' },
+                { name: 'far', type: 'float' },
+        ],
+})
+
+export const viewZ2depthOrthographic = Fn(([viewZ, near, far]: [Float, Float, Float]): Float => {
+        return viewZ.add(near).div(near.sub(far))
+}).setLayout({
+        name: 'viewZ2depthOrthographic',
+        type: 'float',
+        inputs: [
+                { name: 'viewZ', type: 'float' },
+                { name: 'near', type: 'float' },
+                { name: 'far', type: 'float' },
+        ],
+})

package/src/addons/space/windmillTile.ts

@@ -0,0 +1,58 @@
+import { Fn, Vec2, Vec4, Float, mod, abs, vec4 } from '../../node'
+import { rotate2DBasic } from './rotate'
+import { sqTile } from './sqTile'
+
+export const windmillTile = Fn(([t, turn]: [Vec4, Float]): Vec4 => {
+        const a = abs(mod(t.z, 2).sub(mod(t.w, 2)))
+                .add(mod(t.w, 2).mul(2))
+                .mul(0.25)
+        return vec4(rotate2DBasic(t.xy, a.mul(turn)), t.zw)
+}).setLayout({
+        name: 'windmillTile',
+        type: 'vec4',
+        inputs: [
+                { name: 't', type: 'vec4' },
+                { name: 'turn', type: 'float' },
+        ],
+})
+
+export const windmillTileDefault = Fn(([t]: [Vec4]): Vec4 => {
+        const a = abs(mod(t.z, 2).sub(mod(t.w, 2)))
+                .add(mod(t.w, 2).mul(2))
+                .mul(0.25)
+        return vec4(rotate2DBasic(t.xy, a.mul(6.283185307179586)), t.zw)
+}).setLayout({
+        name: 'windmillTileDefault',
+        type: 'vec4',
+        inputs: [{ name: 't', type: 'vec4' }],
+})
+
+export const windmillTileVec2 = Fn(([v]: [Vec2]): Vec4 => {
+        return windmillTileDefault(sqTile(v))
+}).setLayout({
+        name: 'windmillTileVec2',
+        type: 'vec4',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})
+
+export const windmillTileFloat = Fn(([v, s]: [Vec2, Float]): Vec4 => {
+        return windmillTileVec2(v.mul(s))
+}).setLayout({
+        name: 'windmillTileFloat',
+        type: 'vec4',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 's', type: 'float' },
+        ],
+})
+
+export const windmillTileVec2Scale = Fn(([v, s]: [Vec2, Vec2]): Vec4 => {
+        return windmillTileVec2(v.mul(s))
+}).setLayout({
+        name: 'windmillTileVec2Scale',
+        type: 'vec4',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 's', type: 'vec2' },
+        ],
+})

package/src/addons/space/xyz2equirect.ts

@@ -0,0 +1,10 @@
+import { Fn, Vec3, Vec2, vec2, atan2, acos } from '../../node'
+import { PI, TWO_PI } from '../math/const'
+
+export const xyz2equirect = Fn(([d]: [Vec3]): Vec2 => {
+        return vec2(atan2(d.z, d.x).add(PI), acos(d.y.negate())).div(vec2(TWO_PI, PI))
+}).setLayout({
+        name: 'xyz2equirect',
+        type: 'vec2',
+        inputs: [{ name: 'd', type: 'vec3' }],
+})

package/src/index.ts

@@ -30,11 +30,14 @@ export const createGL = (props?: Partial<GL>) => {
                 isWebGL: true,
                 isError: false,
                 isLoop: true,
+                isDebug: false,
+                isDepth: false,
                 isGL: true,
                 size: [0, 0],
                 mouse: [0, 0],
                 count: 6,
-                particles: 1024,
+                instanceCount: 1,
+                particleCount: 1024,
                 webgl: {},
                 webgpu: {},
                 loading: 0,
@@ -50,6 +53,7 @@ export const createGL = (props?: Partial<GL>) => {
         gl.frame = createFrame()
 
         gl.attribute = durable((k, v, i) => gl.queue(() => gl._attribute?.(k, v, i)), gl)
+        gl.instance = durable((k, v, at) => gl.queue(() => gl._instance?.(k, v, at)), gl)
         gl.storage = durable((k, v) => gl.queue(() => gl._storage?.(k, v)), gl)
         gl.uniform = durable((k, v) => gl.queue(() => gl._uniform?.(k, v)), gl)
         gl.texture = durable((k, v) => gl.queue(() => gl._texture?.(k, v)), gl)
@@ -109,4 +113,3 @@ export const createGL = (props?: Partial<GL>) => {
 }
 
 export default createGL
-

package/src/node/build.ts

@@ -25,14 +25,17 @@ const topological = (headers: Map<string, string>, dependencies: Map<string, Set
         return sorted
 }
 
-const generateHead = (x: X, c: NodeContext) => {
+const build = (x: X, c: NodeContext) => {
         const body = code(x, c)
         let head = ''
         if (c.isWebGL && c.code?.dependencies) {
                 const sorted = topological(c.code.headers, c.code.dependencies)
                 head = sorted.map(([, value]) => value).join('\n')
         } else head = Array.from(c.code?.headers?.values() || []).join('\n')
-        return [head, body]
+        let [lines, ret] = body.split('return ')
+        if (ret) ret = ret.replace(';', '')
+        else [lines, ret] = ['', body]
+        return [head, lines.trim(), ret]
 }
 
 const generateStruct = (id: string, map: Map<string, string>) => {
@@ -42,76 +45,83 @@ const generateStruct = (id: string, map: Map<string, string>) => {
 export const fragment = (x: X, c: NodeContext = {}) => {
         c.code?.headers?.clear()
         c.label = 'frag' // for varying inputs or outputs
-        const [head, body] = generateHead(x, c)
-        const ret = []
+        const [head, lines, ret] = build(x, c)
+        const result = []
         if (c.isWebGL) {
-                ret.push(GLSL_FRAGMENT_HEAD)
-                for (const code of c.code?.fragInputs?.values() || []) ret.push(`in ${code}`)
-                ret.push(head)
-                ret.push(`void main() {\n  fragColor = ${body};`)
+                result.push(GLSL_FRAGMENT_HEAD)
+                for (const code of c.code?.fragInputs?.values() || []) result.push(`in ${code}`)
+                result.push(head)
+                result.push('void main() {')
+                result.push(`  ${lines}`)
+                result.push(`  fragColor = ${ret};`)
         } else {
-                if (c.code?.fragInputs?.size) ret.push(generateStruct('Out', c.code.fragInputs))
-                ret.push(head)
-                ret.push(`@fragment\nfn main(out: Out) -> @location(0) vec4f {`)
-                ret.push(`  return ${body};`)
+                if (c.code?.fragInputs?.size) result.push(generateStruct('Out', c.code.fragInputs))
+                result.push(head)
+                result.push(`@fragment\nfn main(out: Out) -> @location(0) vec4f {`)
+                result.push(`  ${lines}`)
+                result.push(`  return ${ret};`)
         }
-        ret.push('}')
-        const main = ret.filter(Boolean).join('\n').trim()
-        // console.log(`↓↓↓generated↓↓↓\n${main}`)
+        result.push('}')
+        const main = result.filter(Boolean).join('\n').trim()
+        if (c.gl?.isDebug) console.log(`↓↓↓generated↓↓↓\n${main}`)
         return main
 }
 
 export const vertex = (x: X, c: NodeContext = {}) => {
         c.code?.headers?.clear()
         c.label = 'vert' // for varying inputs or outputs
-        const [head, body] = generateHead(x, c)
-        const ret = []
+        const [head, lines, ret] = build(x, c)
+        const result = []
         if (c.isWebGL) {
-                ret.push('#version 300 es')
-                for (const code of c.code?.vertInputs?.values() || []) ret.push(`in ${code}`)
-                for (const code of c.code?.vertOutputs?.values() || []) ret.push(`out ${code}`)
-                ret.push(head)
-                ret.push('void main() {')
-                ret.push(`  gl_Position = ${body};`)
-                for (const [id, code] of c.code?.vertVaryings?.entries() || []) ret.push(`  ${id} = ${code};`)
+                result.push('#version 300 es')
+                for (const code of c.code?.vertInputs?.values() || []) result.push(`in ${code}`)
+                for (const code of c.code?.vertOutputs?.values() || []) result.push(`out ${code}`)
+                result.push(head)
+                result.push('void main() {')
+                result.push(`  ${lines}`)
+                result.push(`  gl_Position = ${ret};`)
+                for (const [id, code] of c.code?.vertVaryings?.entries() || []) result.push(`  ${id} = ${code};`)
         } else {
-                if (c.code?.vertInputs?.size) ret.push(generateStruct('In', c.code.vertInputs))
-                if (c.code?.vertOutputs?.size) ret.push(generateStruct('Out', c.code.vertOutputs))
-                ret.push(head)
-                ret.push('@vertex')
-                ret.push(`fn main(${c.code?.vertInputs?.size ? 'in: In' : ''}) -> Out {`)
-                ret.push('  var out: Out;')
-                ret.push(`  out.position = ${body};`)
-                for (const [id, code] of c.code?.vertVaryings?.entries() || []) ret.push(`  out.${id} = ${code};`)
-                ret.push('  return out;')
+                if (c.code?.vertInputs?.size) result.push(generateStruct('In', c.code.vertInputs))
+                if (c.code?.vertOutputs?.size) result.push(generateStruct('Out', c.code.vertOutputs))
+                result.push(head)
+                result.push('@vertex')
+                result.push(`fn main(${c.code?.vertInputs?.size ? 'in: In' : ''}) -> Out {`)
+                result.push('  var out: Out;')
+                result.push(`  ${lines}`)
+                result.push(`  out.position = ${ret};`)
+                for (const [id, code] of c.code?.vertVaryings?.entries() || []) result.push(`  out.${id} = ${code};`)
+                result.push('  return out;')
         }
-        ret.push('}')
-        const main = ret.filter(Boolean).join('\n').trim()
-        // console.log(`↓↓↓generated↓↓↓\n${main}`)
+        result.push('}')
+        const main = result.filter(Boolean).join('\n').trim()
+        if (c.gl?.isDebug) console.log(`↓↓↓generated↓↓↓\n${main}`)
         return main
 }
 
 export const compute = (x: X, c: NodeContext = {}) => {
         c.code?.headers?.clear()
         c.label = 'compute'
-        const [head, body] = generateHead(x, c)
-        const ret = []
+        const [head, lines, ret] = build(x, c)
+        const result = []
         if (c.isWebGL) {
-                ret.push('#version 300 es')
-                ret.push('precision mediump float;')
-                ret.push(head)
-                ret.push('void main() {')
-                ret.push(`  ${body};`)
-                ret.push('}')
+                result.push('#version 300 es')
+                result.push('precision mediump float;')
+                result.push(head)
+                result.push('void main() {')
+                result.push(`  ${lines}`)
+                result.push(`  ${ret};`)
+                result.push('}')
         } else {
-                if (c.code?.computeInputs?.size) ret.push(generateStruct('In', c.code.computeInputs))
-                ret.push(head)
-                ret.push('@compute @workgroup_size(32)')
-                ret.push(`fn main(${c.code?.computeInputs?.size ? 'in: In' : ''}) {`)
-                ret.push(`  ${body};`)
-                ret.push('}')
+                if (c.code?.computeInputs?.size) result.push(generateStruct('In', c.code.computeInputs))
+                result.push(head)
+                result.push('@compute @workgroup_size(32)')
+                result.push(`fn main(${c.code?.computeInputs?.size ? 'in: In' : ''}) {`)
+                result.push(`  ${lines}`)
+                result.push(`  ${ret};`)
+                result.push('}')
         }
-        const main = ret.filter(Boolean).join('\n').trim()
-        // console.log(`↓↓↓generated↓↓↓\n${main}`)
+        const main = result.filter(Boolean).join('\n').trim()
+        if (c.gl?.isDebug) console.log(`↓↓↓generated↓↓↓\n${main}`)
         return main
 }

package/src/node/create.ts

@@ -25,6 +25,7 @@ export const create = <T extends C>(type: NodeTypes, props?: NodeProps | null, .
                 if (key === Symbol.toPrimitive) return toPrimitive.bind(null, x)
                 if (key === 'listeners') return listeners
                 if (key === 'attribute') return (id = getId()) => attribute(x, id)
+                if (key === 'instance') return (id = getId()) => instance(x, id)
                 if (key === 'constant') return (id = getId()) => constant(x, id)
                 if (key === 'uniform') return (id = getId()) => uniform(x, id)
                 if (key === 'variable') return (id = getId()) => variable(id)
@@ -33,6 +34,7 @@ export const create = <T extends C>(type: NodeTypes, props?: NodeProps | null, .
                 if (key === 'element') return (arg: Y) => (type === 'storage' ? gather(x, arg) : element(x, arg))
                 if (key === 'member') return (arg: Y) => member(x, arg)
                 if (key === 'assign') return assign.bind(null, x, x.type === 'gather')
+                if (key === 'select') return select.bind(null, x)
                 if (isOperator(key)) {
                         return key.endsWith('Assign')
                                 ? (...args: Y[]) => addToScope(operator(key, x, ...args))
@@ -53,6 +55,7 @@ export const create = <T extends C>(type: NodeTypes, props?: NodeProps | null, .
 
 // headers with proper type inference
 export const attribute = <T extends C>(x: Y<T>, id = getId()) => create<T>('attribute', { id }, x)
+export const instance = <T extends C>(x: Y<T>, id = getId()) => create<T>('instance', { id }, x)
 export const constant = <T extends C>(x: Y<T>, id = getId()) => create<T>('constant', { id }, x)
 export const uniform = <T extends C>(x: Y<T>, id = getId()) => create<T>('uniform', { id }, x)
 export const storage = <T extends C>(x: Y<T>, id = getId()) => create<T>('storage', { id }, x)

package/src/node/index.ts

@@ -16,7 +16,7 @@ export const fragDepth = b<'float'>('frag_depth')
 export const sampleIndex = b<'uint'>('sample_index')
 export const sampleMask = b<'uint'>('sample_mask')
 export const pointCoord = b<'vec2'>('point_coord')
-export const id = b<'vec3'>('global_invocation_id')
+export const id = b<'uvec3'>('global_invocation_id')
 
 // TSL Compatible Builtin Variables
 export const positionLocal = b<'vec3'>('position')
@@ -124,7 +124,6 @@ export const oneMinus = <T extends C>(x: X<T>) => f<T>('oneMinus', x)
 export const radians = <T extends C>(x: X<T>) => f<T>('radians', x)
 export const reciprocal = <T extends C>(x: X<T>) => f<T>('reciprocal', x)
 export const round = <T extends C>(x: X<T>) => f<T>('round', x)
-export const saturate = <T extends C>(x: X<T>) => f<T>('saturate', x)
 export const sign = <T extends C>(x: X<T>) => f<T>('sign', x)
 export const sin = <T extends C>(x: X<T>) => f<T>('sin', x)
 export const sinh = <T extends C>(x: X<T>) => f<T>('sinh', x)

package/src/node/scope.ts

@@ -1,4 +1,3 @@
-import { getId } from './utils'
 import { conversion, create } from './create'
 import type {
         FnLayout,
@@ -12,6 +11,7 @@ import type {
         X,
         Y,
 } from './types'
+import { getId } from './utils'
 
 let scope: X | null = null
 let define: X | null = null
@@ -42,7 +42,7 @@ export const assign = <T extends C>(x: X<T>, isScatter = false, y: Y<T>): X<T> =
         return x
 }
 
-export const Return = <T extends C>(x: Y<T>): Y<T> => {
+export const Return = <T extends C>(x?: Y<T>): Y<T> => {
         return addToScope(create<T>('return', { inferFrom: [x] }, x))
 }
 
@@ -71,21 +71,24 @@ export const scoped = (x: X, fun: () => X | void, y = define) => {
         ;[scope, define] = [_scope, _define]
 }
 
+export const Scope = <T extends X>(fun: () => T | void) => {
+        const scope = create('scope')
+        scoped(scope, fun)
+        return scope as T
+}
+
 export const If = (x: Y, fun: () => void) => {
-        const y = create('scope')
-        scoped(y, fun)
+        const y = Scope(fun)
         const ifNode = create('if', null, x, y)
         addToScope(ifNode)
         const ret = () => ({
                 ElseIf: (_x: X, _fun: () => void) => {
-                        const _y = create('scope')
-                        scoped(_y, _fun)
+                        const _y = Scope(_fun)
                         ifNode.props.children!.push(_x, _y)
                         return ret()
                 },
                 Else: (_fun: () => void) => {
-                        const _x = create('scope')
-                        scoped(_x, _fun)
+                        const _x = Scope(_fun)
                         ifNode.props.children!.push(_x)
                 },
         })
@@ -93,9 +96,8 @@ export const If = (x: Y, fun: () => void) => {
 }
 
 export const Loop = (x: Y, fun: (params: { i: Int }) => void) => {
-        const y = create('scope')
         const id = getId()
-        scoped(y, () => fun({ i: create<'int'>('variable', { id, inferFrom: [conversion('int', 0)] }) }))
+        const y = Scope(() => fun({ i: create<'int'>('variable', { id, inferFrom: [conversion('int', 0)] }) }))
         const ret = create('loop', { id }, x, y)
         return addToScope(ret)
 }
@@ -106,42 +108,42 @@ export const Switch = (x: Y) => {
         const ret = () => ({
                 Case: (...values: X[]) => {
                         return (fun: () => void) => {
-                                const y = create('scope')
-                                scoped(y, fun)
+                                const y = Scope(fun)
                                 for (const _x of values) switchNode.props.children!.push(_x, y)
                                 return ret()
                         }
                 },
                 Default: (fun: () => void) => {
-                        const scope = create('scope')
-                        scoped(scope, fun)
+                        const scope = Scope(fun)
                         switchNode.props.children!.push(scope)
                 },
         })
         return ret()
 }
 
-export function Fn<T extends X | Struct | void, Args extends any[]>(fun: (args: Args) => T, defaultId = getId()) {
-        let layout: FnLayout
+export function Fn<T extends X | Struct | void, Args extends any[]>(fun: (args: Args) => T, layout?: FnLayout) {
+        const defaultId = getId()
         const ret = (...args: any[]) => {
                 const id = layout?.name || defaultId
-                const x = create('scope')
                 const paramVars: X[] = []
                 const paramDefs: NodeProps[] = []
-                if (layout?.inputs) {
-                        for (const input of layout.inputs) {
-                                paramDefs.push({ id: input.name, inferFrom: [conversion(input.type)] })
-                        }
-                } else {
-                        for (let i = 0; i < args.length; i++) {
-                                paramDefs.push({ id: `p${i}`, inferFrom: [args[i]] })
-                        }
+                for (let i = 0; i < args.length; i++) {
+                        const input = layout?.inputs?.[i]
+                        if (!input) paramDefs.push({ id: `p${i}`, inferFrom: [args[i]] })
+                        else
+                                paramDefs.push({
+                                        id: input.name,
+                                        inferFrom:
+                                                input.type === 'auto' ? [args[i]] : [conversion(input.type, args[i])],
+                                })
                 }
                 for (const props of paramDefs) paramVars.push(create('variable', props))
+                const x = create('scope')
                 const y = create('define', { id, layout }, x, ...args)
                 scoped(x, () => fun(paramVars as Args) as any, y)
                 return y
         }
+        ret.getLayout = () => layout
         ret.setLayout = (_layout: FnLayout) => {
                 layout = _layout
                 return ret

package/src/node/types.ts

@@ -14,12 +14,13 @@ export interface FnLayout {
         type: C | 'auto'
         inputs?: Array<{
                 name: string
-                type: C
+                type: C | 'auto'
         }>
 }
 
 export interface FnType<T extends X | Struct | void, Args extends any[]> {
         (...args: Args): T extends void ? Void : T
+        getLayout(): FnLayout
         setLayout(layout: FnLayout): FnType<T, Args>
 }
 
@@ -35,6 +36,7 @@ export interface StructFactory<T extends StructFields> {
 export type NodeTypes =
         // headers
         | 'attribute'
+        | 'instance'
         | 'storage'
         | 'uniform'
         | 'constant'
@@ -222,7 +224,7 @@ type XImpl<T extends C> = _X<T> & {
 type C = Constants
 
 export type X<T extends C = C> = T extends keyof ConstantsToType ? ConstantsToType[T] : _X<T>
-export type Y<T extends C = C> = number | number[] | string | boolean | undefined | X<T>
+export type Y<T extends C = C> = number | number[] | string | boolean | undefined | HTMLElement | X<T>
 
 type Methods =
         | Functions
@@ -238,11 +240,13 @@ type Methods =
         | 'toVar'
         | 'toString'
         | 'element'
+        | 'select'
 
 interface _X<T extends C> {
         // System properties
         readonly __nodeType?: T
         assign(x: any): X<T>
+        select(x: number | X<T>, y: X<'bool'>): X<T>
         fragment(c: NodeContext): string
         toVar(name?: string): X<T>
         toString(c?: NodeContext): string
@@ -298,20 +302,20 @@ interface _X<T extends C> {
 
         // Conversion methods
         toBool(): Bool
-        toUint(): UInt
+        toUInt(): UInt
         toInt(): Int
         toFloat(): Float
-        toBvec2(): BVec2
-        toIvec2(): IVec2
-        toUvec2(): UVec2
+        toBVec2(): BVec2
+        toIVec2(): IVec2
+        toUVec2(): UVec2
         toVec2(): Vec2
-        toBvec3(): BVec3
-        toIvec3(): IVec3
-        toUvec3(): UVec3
+        toBVec3(): BVec3
+        toIVec3(): IVec3
+        toUVec3(): UVec3
         toVec3(): Vec3
-        toBvec4(): BVec4
-        toIvec4(): IVec4
-        toUvec4(): UVec4
+        toBVec4(): BVec4
+        toIVec4(): IVec4
+        toUVec4(): UVec4
         toVec4(): Vec4
         toColor(): Color
         toMat2(): Mat2