glre 0.38.0 → 0.40.0

package/src/node/index.ts

@@ -1,9 +1,9 @@
 import { hex2rgb } from './utils'
-import { builtin as b, conversion as c, function_ as f, uniform as u } from './node'
+import { builtin as b, conversion as c, function_ as f, uniform as u } from './create'
 import { is } from '../utils/helpers'
-import type { Constants as C, X, NodeProxy } from './types'
-export * from './core'
-export * from './node'
+import type { Constants as C, Float, X, Y } from './types'
+export * from './build'
+export * from './create'
 export * from './scope'
 export * from './types'
 
@@ -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')
@@ -29,28 +29,28 @@ export const screenCoordinate = b<'vec2'>('screenCoordinate')
 export const screenUV = b<'vec2'>('screenUV')
 
 // Type constructors with proper type inference
-export const float = (x?: X) => c('float', x)
-export const int = (x?: X) => c('int', x)
-export const uint = (x?: X) => c('uint', x)
-export const bool = (x?: X) => c('bool', x)
-export const vec2 = (x?: X, y?: X) => c('vec2', x, y)
-export const vec3 = (x?: X, y?: X, z?: X) => c('vec3', x, y, z)
-export const vec4 = (x?: X, y?: X, z?: X, w?: X) => c('vec4', x, y, z, w)
-export const mat2 = (...args: X[]) => c('mat2', ...args)
-export const mat3 = (...args: X[]) => c('mat3', ...args)
-export const mat4 = (...args: X[]) => c('mat4', ...args)
-export const ivec2 = (x?: X, y?: X) => c('ivec2', x, y)
-export const ivec3 = (x?: X, y?: X, z?: X) => c('ivec3', x, y, z)
-export const ivec4 = (x?: X, y?: X, z?: X, w?: X) => c('ivec4', x, y, z, w)
-export const uvec2 = (x?: X, y?: X) => c('uvec2', x, y)
-export const uvec3 = (x?: X, y?: X, z?: X) => c('uvec3', x, y, z)
-export const uvec4 = (x?: X, y?: X, z?: X, w?: X) => c('uvec4', x, y, z, w)
-export const bvec2 = (x?: X, y?: X) => c('bvec2', x, y)
-export const bvec3 = (x?: X, y?: X, z?: X) => c('bvec3', x, y, z)
-export const bvec4 = (x?: X, y?: X, z?: X, w?: X) => c('bvec4', x, y, z, w)
-export const texture2D = (x?: X) => c('texture', x)
+export const float = (x?: Y) => c('float', x)
+export const int = (x?: Y) => c('int', x)
+export const uint = (x?: Y) => c('uint', x)
+export const bool = (x?: Y) => c('bool', x)
+export const vec2 = (x?: Y, y?: Y) => c('vec2', x, y)
+export const vec3 = (x?: Y, y?: Y, z?: Y) => c('vec3', x, y, z)
+export const vec4 = (x?: Y, y?: Y, z?: Y, w?: Y) => c('vec4', x, y, z, w)
+export const mat2 = (...args: Y[]) => c('mat2', ...args)
+export const mat3 = (...args: Y[]) => c('mat3', ...args)
+export const mat4 = (...args: Y[]) => c('mat4', ...args)
+export const ivec2 = (x?: Y, y?: Y) => c('ivec2', x, y)
+export const ivec3 = (x?: Y, y?: Y, z?: Y) => c('ivec3', x, y, z)
+export const ivec4 = (x?: Y, y?: Y, z?: Y, w?: Y) => c('ivec4', x, y, z, w)
+export const uvec2 = (x?: Y, y?: Y) => c('uvec2', x, y)
+export const uvec3 = (x?: Y, y?: Y, z?: Y) => c('uvec3', x, y, z)
+export const uvec4 = (x?: Y, y?: Y, z?: Y, w?: Y) => c('uvec4', x, y, z, w)
+export const bvec2 = (x?: Y, y?: Y) => c('bvec2', x, y)
+export const bvec3 = (x?: Y, y?: Y, z?: Y) => c('bvec3', x, y, z)
+export const bvec4 = (x?: Y, y?: Y, z?: Y, w?: Y) => c('bvec4', x, y, z, w)
+export const texture2D = (x?: Y) => c('texture', x)
 export const sampler2D = () => c('sampler2D')
-export const color = (r?: X, g?: X, b?: X) => {
+export const color = (r?: Y, g?: Y, b?: Y) => {
         if (is.num(r) && is.und(g) && is.und(b)) return vec3(...hex2rgb(r))
         return vec3(r, g, b)
 }
@@ -64,20 +64,26 @@ export const uv = position.xy.div(iResolution)
 /**
  * 1.1. unified with:
  * 2.1. const.ts BUILTIN_VARIABLES and
- * 3.1. types.ts BaseNodeProxy
+ * 3.1. types.ts _N
  */
 // 0. Always return bool
 export const all = <T extends C>(x: X<T>) => f<'bool'>('all', x)
 export const any = <T extends C>(x: X<T>) => f<'bool'>('any', x)
 
-// 2. Always return float
-export const length = (x: X) => f<'float'>('length', x)
+// 2. Always return float with WGSL-compliant type constraints and unified parameter types
+export const determinant = <T extends 'mat2' | 'mat3' | 'mat4'>(x: X<T>) => f<'float'>('determinant', x)
+export const distance = <T extends 'vec2' | 'vec3' | 'vec4', U extends C>(x: X<T>, y: number | X<U>) =>
+        f<'float'>('distance', x, y)
+export const dot = <T extends 'vec2' | 'vec3' | 'vec4' | 'ivec2' | 'ivec3' | 'ivec4', U extends C>(
+        x: X<T>,
+        y: number | X<U>
+) => f<T extends `ivec${string}` ? 'int' : 'float'>('dot', x, y)
+export const length = <T extends 'vec2' | 'vec3' | 'vec4'>(x: X<T>) => f<'float'>('length', x)
 export const lengthSq = (x: X) => f<'float'>('lengthSq', x)
-export const distance = (x: X, y: X) => f<'float'>('distance', x, y)
-export const dot = (x: X, y: X) => f<'float'>('dot', x, y)
+export const luminance = (x: X) => f<'float'>('luminance', x)
 
-// 3. Always return vec3
-export const cross = (x: X<'vec3'>, y: X<'vec3'>) => f<'vec3'>('cross', x, y)
+// 3. Always return vec3 with vec3 constraint and unified parameter types
+export const cross = <U extends C = 'vec3'>(x: X<'vec3'>, y: number | X<U>) => f<'vec3'>('cross', x, y)
 
 // 4. Always return vec4
 export const cubeTexture = (x: X, y: X, z?: X) => f<'vec4'>('cubeTexture', x, y, z)
@@ -88,7 +94,7 @@ export const textureLod = (x: X, y: X, z?: X) => f<'vec4'>('textureLod', x, y, z
 /**
  * 1.2. unified with:
  * 2.2. const.ts FUNCTIONS and
- * 3.2. types.ts BaseNodeProxy
+ * 3.2. types.ts _N
  */
 // 0. Component-wise functions
 export const abs = <T extends C>(x: X<T>) => f<T>('abs', x)
@@ -113,12 +119,11 @@ export const inverseSqrt = <T extends C>(x: X<T>) => f<T>('inverseSqrt', x)
 export const log = <T extends C>(x: X<T>) => f<T>('log', x)
 export const log2 = <T extends C>(x: X<T>) => f<T>('log2', x)
 export const negate = <T extends C>(x: X<T>) => f<T>('negate', x)
-export const normalize = <T extends C>(x: X<T>) => f<T>('normalize', x)
+export const normalize = <T extends 'vec2' | 'vec3' | 'vec4'>(x: X<T>) => f<T>('normalize', x)
 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)
@@ -127,17 +132,27 @@ export const tan = <T extends C>(x: X<T>) => f<T>('tan', x)
 export const tanh = <T extends C>(x: X<T>) => f<T>('tanh', x)
 export const trunc = <T extends C>(x: X<T>) => f<T>('trunc', x)
 
-// 1. Functions where first argument determines return type
-export const atan2 = <T extends C>(x: X<T>, y: X) => f<T>('atan2', x, y)
-export const clamp = <T extends C>(x: X<T>, y: X, z: X) => f<T>('clamp', x, y, z)
-export const max = <T extends C>(x: X<T>, y: X) => f<T>('max', x, y)
-export const min = <T extends C>(x: X<T>, y: X) => f<T>('min', x, y)
-export const mix = <T extends C>(x: X<T>, y: X, a: X) => f<T>('mix', x, y, a)
-export const pow = <T extends C>(x: X<T>, y: X) => f<T>('pow', x, y)
-export const reflect = <T extends C>(I: X<T>, N: X) => f<T>('reflect', I, N)
-export const refract = <T extends C>(I: X<T>, N: X, eta: X) => f<T>('refract', I, N, eta)
+// 1. Functions where first argument determines return type with unified parameter types
+export const atan2 = <T extends C, U extends C>(x: X<T>, y: number | X<U>) => f<T>('atan2', x, y)
+export const clamp = <T extends C, U extends C>(x: X<T>, min: number | X<U>, max: number | X<U>) =>
+        f<T>('clamp', x, min, max)
+export const max = <T extends C, U extends C>(x: X<T>, y: number | X<U>) => f<T>('max', x, y)
+export const min = <T extends C, U extends C>(x: X<T>, y: number | X<U>) => f<T>('min', x, y)
+export const mix = <T extends C, U extends C>(x: X<T>, y: number | X<U>, a: number | Float | X<U>) =>
+        f<T>('mix', x, y, a)
+export const pow = <T extends C, U extends C>(x: X<T>, y: number | X<U>) => f<T>('pow', x, y)
+export const reflect = <T extends 'vec2' | 'vec3' | 'vec4', U extends C>(I: X<T>, N: number | X<U>) =>
+        f<T>('reflect', I, N)
+export const refract = <T extends 'vec2' | 'vec3' | 'vec4', U extends C>(
+        I: X<T>,
+        N: number | X<U>,
+        eta: number | Float
+) => f<T>('refract', I, N, eta)
 
-// 2. Functions where not first argument determines return type
-export const smoothstep = <T extends C>(e0: X, e1: X, x: X<T>) => f<T>('smoothstep', e0, e1, x)
-export const step = <T extends C>(edge: X, x: X<T>) => f<T>('step', edge, x)
-export const mod = <T extends C>(x: NodeProxy<T>, y: X<T>) => x.sub(x.div(y).toFloat().floor().mul(y))
+// 2. Functions where not first argument determines return type with unified parameter types
+export const smoothstep = <T extends C, U extends C>(e0: number | X<U>, e1: number | X<U>, x: X<T>) =>
+        f<T>('smoothstep', e0, e1, x)
+export const step = <T extends C, U extends C>(edge: number | X<U>, x: X<T>) => f<T>('step', edge, x)
+export const mod = <T extends C, U extends C>(x: X<T>, y: number | X<U>) => {
+        return (x as any).sub((x as any).div(y).floor().mul(y)) as X<T>
+}

package/src/node/scope.ts

@@ -1,62 +1,69 @@
 import { getId } from './utils'
-import { conversion, node } from './node'
+import { conversion, create } from './create'
 import type {
         FnLayout,
         FnType,
-        NodeProps,
-        NodeProxy,
-        X,
-        Constants,
+        Constants as C,
         Int,
+        NodeProps,
+        Struct,
         StructFactory,
-        StructNode,
         StructFields,
+        X,
+        Y,
 } from './types'
 
-let scope: NodeProxy | null = null
-let define: NodeProxy | null = null
+let scope: X | null = null
+let define: X | null = null
 
-const addToScope = (x: NodeProxy) => {
+export const addToScope = <T extends C>(x: X<T>) => {
         if (!scope) return
         if (!scope.props.children) scope.props.children = []
         scope.props.children.push(x)
-        if (x.type !== 'return' || !define) return
+        if (x.type !== 'return' || !define) return x
         const { props } = define
         if (!props.inferFrom) props.inferFrom = []
         props.inferFrom.push(x)
+        return x
 }
 
-export function toVar<T extends StructFields>(x: StructNode<T>, id?: string): StructNode<T>
-export function toVar<T extends Constants>(x: NodeProxy<T>, id?: string): NodeProxy<T> {
+export function toVar<T extends StructFields>(x: Struct<T>, id?: string): Struct<T>
+export function toVar<T extends C>(x: X<T>, id?: string): X<T> {
         if (!id) id = getId()
-        const y = node<T>('variable', { id, inferFrom: [x] })
-        const z = node<T>('declare', null, x as NodeProxy, y)
+        const y = create<T>('variable', { id, inferFrom: [x] })
+        const z = create<T>('declare', null, x as X, y)
         addToScope(z)
         return y
 }
 
-export const assign = <T extends Constants>(x: NodeProxy<T>, isScatter = false, y: X<T>): X<T> => {
-        const z = node(isScatter ? 'scatter' : 'assign', null, x, y)
+export const assign = <T extends C>(x: X<T>, isScatter = false, y: Y<T>): X<T> => {
+        const z = create(isScatter ? 'scatter' : 'assign', null, x, y)
         addToScope(z)
         return x
 }
 
-export const Return = <T extends Constants>(x: X<T>): NodeProxy<T> => {
-        const y = node<T>('return', { inferFrom: [x] }, x)
-        addToScope(y)
-        return y
+export const Return = <T extends C>(x?: Y<T>): Y<T> => {
+        return addToScope(create<T>('return', { inferFrom: [x] }, x))
+}
+
+export const Break = (): Y => {
+        return addToScope(create('break'))
+}
+
+export const Continue = (): Y => {
+        return addToScope(create('continue'))
 }
 
 export const struct = <T extends StructFields>(fields: T, id = getId()): StructFactory<T> => {
         return (initialValues: StructFields = {}, instanceId = getId()) => {
-                const x = node('variable', { id: instanceId, inferFrom: [id] })
-                const y = node('struct', { id, fields, initialValues }, x)
+                const x = create('variable', { id: instanceId, inferFrom: [id] })
+                const y = create('struct', { id, fields, initialValues }, x)
                 addToScope(y)
-                return x as StructNode<T>
+                return x as Struct<T>
         }
 }
 
-const scoped = (x: NodeProxy, fun: () => NodeProxy | void, y = define) => {
+export const scoped = (x: X, fun: () => X | void, y = define) => {
         const [_scope, _define] = [scope, define]
         ;[scope, define] = [x, y]
         const z = fun()
@@ -64,81 +71,78 @@ const scoped = (x: NodeProxy, fun: () => NodeProxy | void, y = define) => {
         ;[scope, define] = [_scope, _define]
 }
 
-export const If = (x: NodeProxy, fun: () => void) => {
-        const y = node('scope')
-        scoped(y, fun)
-        const ifNode = node('if', null, x, y)
+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 = Scope(fun)
+        const ifNode = create('if', null, x, y)
         addToScope(ifNode)
         const ret = () => ({
                 ElseIf: (_x: X, _fun: () => void) => {
-                        const _y = node('scope')
-                        scoped(_y, _fun)
+                        const _y = Scope(_fun)
                         ifNode.props.children!.push(_x, _y)
                         return ret()
                 },
                 Else: (_fun: () => void) => {
-                        const _x = node('scope')
-                        scoped(_x, _fun)
+                        const _x = Scope(_fun)
                         ifNode.props.children!.push(_x)
                 },
         })
         return ret()
 }
 
-export const Loop = (x: NodeProxy, fun: (params: { i: Int }) => void) => {
-        const y = node('scope')
+export const Loop = (x: Y, fun: (params: { i: Int }) => void) => {
         const id = getId()
-        scoped(y, () => fun({ i: node<'int'>('variable', { id, inferFrom: [conversion('int', 0)] }) }))
-        const ret = node('loop', { id }, x, y)
-        addToScope(ret)
-        return ret
+        const y = Scope(() => fun({ i: create<'int'>('variable', { id, inferFrom: [conversion('int', 0)] }) }))
+        const ret = create('loop', { id }, x, y)
+        return addToScope(ret)
 }
 
-export const Switch = (x: NodeProxy) => {
-        const switchNode = node('switch', null, x)
+export const Switch = (x: Y) => {
+        const switchNode = create('switch', null, x)
         addToScope(switchNode)
         const ret = () => ({
                 Case: (...values: X[]) => {
                         return (fun: () => void) => {
-                                const y = node('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 = node('scope')
-                        scoped(scope, fun)
+                        const scope = Scope(fun)
                         switchNode.props.children!.push(scope)
                 },
         })
         return ret()
 }
 
-export function Fn<T extends NodeProxy | StructNode | 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 ret = (...args: any[]) => {
-                const id = layout?.name || defaultId
-                const x = node('scope')
-                const paramVars: NodeProxy[] = []
+                const id = layout?.name || getId()
+                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(node('variable', props))
-                const y = node('define', { id, layout }, x, ...args)
+                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