glre 0.25.0 → 0.27.0

package/src/node/const.ts

@@ -1,5 +1,6 @@
-// 基本型定数
-export const TYPES = [
+export const SWIZZLES = ['x', 'y', 'z', 'w', 'r', 'g', 'b', 'a', 's', 't', 'p', 'q'] as const
+
+export const NODE_TYPES = [
         'float',
         'int',
         'uint',
@@ -22,48 +23,29 @@ export const TYPES = [
         'bvec4',
 ] as const
 
-export type NodeType = (typeof TYPES)[number]
-
-// スウィズル定数
-export const SWIZZLES = ['x', 'y', 'z', 'w', 'r', 'g', 'b', 'a', 's', 't', 'p', 'q'] as const
-
-type AllSwizzles<T extends string> = T | `${T}${T}` | `${T}${T}${T}` | `${T}${T}${T}${T}`
+export const OPERATORS = {
+        add: '+',
+        sub: '-',
+        mul: '*',
+        div: '/',
+        mod: '%',
+        equal: '==',
+        notEqual: '!=',
+        lessThan: '<',
+        lessThanEqual: '<=',
+        greaterThan: '>',
+        greaterThanEqual: '>=',
+        and: '&&',
+        or: '||',
+        bitAnd: '&',
+        bitOr: '|',
+        bitXor: '^',
+        shiftLeft: '<<',
+        shiftRight: '>>',
+} as const
 
-export type Swillzes =
-        | AllSwizzles<'x' | 'y' | 'z' | 'w'>
-        | AllSwizzles<'r' | 'g' | 'b' | 'a'>
-        | AllSwizzles<'p' | 'q'>
-        | AllSwizzles<'s' | 't'>
+export const OPERATOR_KEYS = Object.keys(OPERATORS) as (keyof typeof OPERATORS)[]
 
-// 演算子定数
-export const OPERATORS = [
-        'add',
-        'sub',
-        'mul',
-        'div',
-        'mod',
-        'equal',
-        'notEqual',
-        'lessThan',
-        'lessThanEqual',
-        'greaterThan',
-        'greaterThanEqual',
-        'and',
-        'or',
-        'not',
-        'assign',
-        'xor',
-        'bitAnd',
-        'bitNot',
-        'bitOr',
-        'bitXor',
-        'shiftLeft',
-        'shiftRight',
-] as const
-
-export type Operator = (typeof OPERATORS)[number]
-
-// 数学関数定数
 export const FUNCTIONS = [
         'abs',
         'acos',
@@ -122,9 +104,24 @@ export const FUNCTIONS = [
         'trunc',
 ] as const
 
-export type MathFunction = (typeof FUNCTIONS)[number]
-
-// キャッシュ用定数
-export const CACHE_BOOLS = [true, false] as const
-export const CACHE_INTS = [0, 1, 2, 3, 4, 5] as const
-export const CACHE_FLOATS = [0.0, 1.0, 0.5, 2.0] as const
+export const TYPE_MAPPING = {
+        float: 'f32',
+        int: 'i32',
+        uint: 'u32',
+        bool: 'bool',
+        vec2: 'vec2f',
+        vec3: 'vec3f',
+        vec4: 'vec4f',
+        mat2: 'mat2x2f',
+        mat3: 'mat3x3f',
+        mat4: 'mat4x4f',
+        ivec2: 'vec2i',
+        ivec3: 'vec3i',
+        ivec4: 'vec4i',
+        uvec2: 'vec2u',
+        uvec3: 'vec3u',
+        uvec4: 'vec4u',
+        bvec2: 'vec2<bool>',
+        bvec3: 'vec3<bool>',
+        bvec4: 'vec4<bool>',
+} as const

package/src/node/index.ts

@@ -1,93 +1,91 @@
-import { float } from './conv'
-import { node } from './node'
-import { uniform } from './uniform'
-import { is } from '../utils/helpers'
-import type { X, FunctionNode, ConditionalNode } from './types'
-export type { X, FunctionNode, ConditionalNode }
-export * from './cache'
+import { f, n, node, u } from './node'
+import type { X } from './types'
+export * from './code'
 export * from './const'
-export * from './conv'
 export * from './node'
+export * from './scope'
 export * from './types'
-export * from './uniform'
+export * from './utils'
 
-// 関数定義
-export const Fn = (jsFunc: Function): FunctionNode => {
-        const functionNode = (...args: any[]) => {
-                const inputs = args.map((arg) => {
-                        if (is.obj(arg) && 'type' in arg && arg.type) return arg
-                        return float(arg)
-                })
-                const result = jsFunc(inputs)
-                return result || float(0)
-        }
-        functionNode.call = (inputs: X[]) => jsFunc(inputs)
-        return functionNode as FunctionNode
-}
+// Default uniforms
+export const iResolution = u('iResolution', [1280, 800])
+export const iMouse = u('iMouse', [0, 0])
+export const iTime = u('iTime', 0)
+export const fragCoord = node('variable', { id: 'fragCoord' })
 
-// 条件分岐
-export const If = (condition: X, callback: () => void): ConditionalNode => {
-        callback()
+// Type constructors
+export const float = (x: X) => n('float', x)
+export const int = (x: X) => n('int', x)
+export const uint = (x: X) => n('uint', x)
+export const bool = (x: X) => n('bool', x)
+export const vec2 = (x?: X, y?: X) => n('vec2', x, y)
+export const vec3 = (x?: X, y?: X, z?: X) => n('vec3', x, y, z)
+export const vec4 = (x?: X, y?: X, z?: X, w?: X) => n('vec4', x, y, z, w)
+export const mat2 = (...args: X[]) => n('mat2', ...args)
+export const mat3 = (...args: X[]) => n('mat3', ...args)
+export const mat4 = (...args: X[]) => n('mat4', ...args)
+export const ivec2 = (x?: X, y?: X) => n('ivec2', x, y)
+export const ivec3 = (x?: X, y?: X, z?: X) => n('ivec3', x, y, z)
+export const ivec4 = (x?: X, y?: X, z?: X, w?: X) => n('ivec4', x, y, z, w)
+export const uvec2 = (x?: X, y?: X) => n('uvec2', x, y)
+export const uvec3 = (x?: X, y?: X, z?: X) => n('uvec3', x, y, z)
+export const uvec4 = (x?: X, y?: X, z?: X, w?: X) => n('uvec4', x, y, z, w)
+export const bvec2 = (x?: X, y?: X) => n('bvec2', x, y)
+export const bvec3 = (x?: X, y?: X, z?: X) => n('bvec3', x, y, z)
+export const bvec4 = (x?: X, y?: X, z?: X, w?: X) => n('bvec4', x, y, z, w)
 
-        const conditionalNode = {
-                ElseIf(newCondition: X, newCallback: () => void): ConditionalNode {
-                        newCallback()
-                        return conditionalNode
-                },
-                Else(elseCallback: () => void) {
-                        elseCallback()
-                },
-        }
-
-        return conditionalNode
-}
-
-// 組み込み変数
-export const fragCoord = node('vec4', undefined)
-export const position = node('vec4', undefined)
-export const iTime = uniform(0.0)
-export const iResolution = uniform([1920, 1080])
-export const iMouse = uniform([0, 0])
-
-// 数学関数
-export const abs = (x: X) => x.abs()
-export const sin = (x: X) => x.sin()
-export const cos = (x: X) => x.cos()
-export const tan = (x: X) => x.tan()
-export const sqrt = (x: X) => x.sqrt()
-export const floor = (x: X) => x.floor()
-export const ceil = (x: X) => x.ceil()
-export const fract = (x: X) => x.fract()
-export const normalize = (x: X) => x.normalize()
-export const length = (x: X) => x.length()
-
-/**
- * @TODO FIX
-export const min = (a: X, b: X) => {
-        return node('float', undefined, {
-                mathFunction: 'min',
-                children: [a as any, b as any],
-        })
-}
-
-export const max = (a: X, b: X) => {
-        return node('float', undefined, {
-                mathFunction: 'max',
-                children: [a as any, b as any],
-        })
-}
-
-export const mix = (a: X, b: X, t: X) => {
-        return node('float', undefined, {
-                mathFunction: 'mix',
-                children: [a as any, b as any, t as any],
-        })
-}
-
-export const clamp = (x: X, min: X, max: X) => {
-        return node('float', undefined, {
-                mathFunction: 'clamp',
-                children: [x as any, min as any, max as any],
-        })
-}
-*/
+// Math Functions
+export const abs = (x: X) => f('abs', x) // Return the absolute value of the parameter.
+export const acos = (x: X) => f('acos', x) // Return the arccosine of the parameter.
+export const all = (x: X) => f('all', x) // Return true if all components of x are true.
+export const any = (x: X) => f('any', x) // Return true if any component of x is true.
+export const asin = (x: X) => f('asin', x) // Return the arcsine of the parameter.
+export const atan = (y: X, x: X) => f('atan', y, x) // Return the arc-tangent of the parameters.
+export const bitcast = (x: X, y: X) => f('bitcast', x, y) // Reinterpret the bits of a value as a different type.
+export const cbrt = (x: X) => f('cbrt', x) // Return the cube root of the parameter.
+export const ceil = (x: X) => f('ceil', x) // Find the nearest integer that is greater than or equal to the parameter.
+export const clamp = (x: X, min: X, max: X) => f('clamp', x, min, max) // Constrain a value to lie between two further values.
+export const cos = (x: X) => f('cos', x) // Return the cosine of the parameter.
+export const cross = (x: X, y: X) => f('cross', x, y) // Calculate the cross product of two vectors.
+export const dFdx = (p: X) => f('dFdx', p) // Return the partial derivative of an argument with respect to x.
+export const dFdy = (p: X) => f('dFdy', p) // Return the partial derivative of an argument with respect to y.
+export const degrees = (radians: X) => f('degrees', radians) // Convert a quantity in radians to degrees.
+export const difference = (x: X, y: X) => f('difference', x, y) // Calculate the absolute difference between two values.
+export const distance = (x: X, y: X) => f('distance', x, y) // Calculate the distance between two points.
+export const dot = (x: X, y: X) => f('dot', x, y) // Calculate the dot product of two vectors.
+export const equals = (x: X, y: X) => f('equals', x, y) // Return true if x equals y.
+export const exp = (x: X) => f('exp', x) // Return the natural exponentiation of the parameter.
+export const exp2 = (x: X) => f('exp2', x) // Return 2 raised to the power of the parameter.
+export const faceforward = (N: X, I: X, Nref: X) => f('faceforward', N, I, Nref) // Return a vector pointing in the same direction as another.
+export const floor = (x: X) => f('floor', x) // Find the nearest integer less than or equal to the parameter.
+export const fract = (x: X) => f('fract', x) // Compute the fractional part of the argument.
+export const fwidth = (x: X) => f('fwidth', x) // Return the sum of the absolute derivatives in x and y.
+export const inverseSqrt = (x: X) => f('inverseSqrt', x) // Return the inverse of the square root of the parameter.
+export const length = (x: X) => f('length', x) // Calculate the length of a vector.
+export const lengthSq = (x: X) => f('lengthSq', x) // Calculate the squared length of a vector.
+export const log = (x: X) => f('log', x) // Return the natural logarithm of the parameter.
+export const log2 = (x: X) => f('log2', x) // Return the base 2 logarithm of the parameter.
+export const max = (x: X, y: X) => f('max', x, y) // Return the greater of two values.
+export const min = (x: X, y: X) => f('min', x, y) // Return the lesser of two values.
+export const mix = (x: X, y: X, a: X) => f('mix', x, y, a) // Linearly interpolate between two values.
+export const negate = (x: X) => f('negate', x) // Negate the value of the parameter ( -x ).
+export const normalize = (x: X) => f('normalize', x) // Calculate the unit vector in the same direction as the original vector.
+export const oneMinus = (x: X) => f('oneMinus', x) // Return 1 minus the parameter.
+export const pow = (x: X, y: X) => f('pow', x, y) // Return the value of the first parameter raised to the power of the second.
+export const pow2 = (x: X) => f('pow2', x) // Return the square of the parameter.
+export const pow3 = (x: X) => f('pow3', x) // Return the cube of the parameter.
+export const pow4 = (x: X) => f('pow4', x) // Return the fourth power of the parameter.
+export const radians = (degrees: X) => f('radians', degrees) // Convert a quantity in degrees to radians.
+export const reciprocal = (x: X) => f('reciprocal', x) // Return the reciprocal of the parameter (1/x).
+export const reflect = (I: X, N: X) => f('reflect', I, N) // Calculate the reflection direction for an incident vector.
+export const refract = (I: X, N: X, eta: X) => f('refract', I, N, eta) // Calculate the refraction direction for an incident vector.
+export const round = (x: X) => f('round', x) // Round the parameter to the nearest integer.
+export const saturate = (x: X) => f('saturate', x) // Constrain a value between 0 and 1.
+export const sign = (x: X) => f('sign', x) // Extract the sign of the parameter.
+export const sin = (x: X) => f('sin', x) // Return the sine of the parameter.
+export const smoothstep = (e0: X, e1: X, x: X) => f('smoothstep', e0, e1, x) // Perform Hermite interpolation between two values.
+export const sqrt = (x: X) => f('sqrt', x) // Return the square root of the parameter.
+export const step = (edge: X, x: X) => f('step', edge, x) // Generate a step function by comparing two values.
+export const tan = (x: X) => f('tan', x) // Return the tangent of the parameter.
+export const transformDirection = (dir: X, matrix: X) => f('transformDirection', dir, matrix) // Transform the direction of a vector by a matrix and then normalize the result.
+export const trunc = (x: X) => f('trunc', x) // Truncate the parameter, removing the fractional part.

package/src/node/node.ts

@@ -1,100 +1,46 @@
-import { OPERATORS, FUNCTIONS, SWIZZLES } from './const'
-import { is } from '../utils/helpers'
-import type { NodeType } from './const'
-import type { Node, ProxyCallback, X } from './types'
-
-let nodeIdCounter = 0
-
-// ノードIDを生成
-const generateNodeId = () => `node_${++nodeIdCounter}`
-
-// ノードを作成
-export const createNode = (type: NodeType, value?: any, options?: Partial<Node>): Node => {
-        return {
-                id: generateNodeId(),
-                type,
-                value,
-                children: [],
-                ...options,
+import { code } from './code'
+import { assign, toVar } from './scope'
+import { getId, isFunction, isOperator, isSwizzle } from './utils'
+import type { Functions, NodeProps, NodeProxy, NodeTypes, Operators, Swizzles, X } from './types'
+
+const toPrimitive = (x: X) => {
+        return (hint: string) => {
+                if (hint === 'string') return code(x)
         }
 }
 
-const isSwizzleProperty = (key = '') => SWIZZLES.includes(key as any)
-const isOperatorMethod = (key = '') => OPERATORS.includes(key as any)
-const isMathMethod = (key = '') => FUNCTIONS.includes(key as any)
-
-// Proxyハンドラーを作成
-const createNodeProxy = (node: Node, callback?: (info: ProxyCallback) => X) => {
-        const get = (_target: unknown, key: unknown) => {
-                if (!is.str(key) || key === 'then') return void 0
-
-                if (key === 'id') return node.id
-                if (key === 'type') return node.type
-                if (key === 'value') return node.value
-                if (key === 'property') return node.property
-
-                // swizzle prooerty
-                if (isSwizzleProperty(key))
-                        return createNodeProxy(
-                                createNode(getSwizzleType(key), undefined, {
-                                        parent: node,
-                                        property: key,
-                                }),
-                                callback
-                        )
-
-                // 演算子メソッド
-                if (isOperatorMethod(key))
-                        return (...args: any[]) => {
-                                return createNodeProxy(
-                                        createNode(node.type, undefined, {
-                                                operator: key as any,
-                                                children: [node, ...args],
-                                        }),
-                                        callback
-                                )
-                        }
-
-                // 数学関数メソッド
-                if (isMathMethod(key))
-                        return (...args: any[]) => {
-                                return createNodeProxy(
-                                        createNode(getMathReturnType(key, node.type), undefined, {
-                                                mathFunction: key as any,
-                                                children: [node, ...args],
-                                        }),
-                                        callback
-                                )
+export const node = (type: NodeTypes, props?: NodeProps | null, ...args: X[]) => {
+        if (!props) props = {}
+        if (args.length) props.children = args
+        const x = new Proxy(() => {}, {
+                get(_, key) {
+                        if (key === 'type') return type
+                        if (key === 'props') return props
+                        if (key === 'toVar') return toVar(x)
+                        if (key === 'assign') return assign(x)
+                        if (key === 'isProxy') return true
+                        if (key === 'toString') return code.bind(null, x)
+                        if (key === Symbol.toPrimitive) return toPrimitive(x)
+                        if (isSwizzle(key)) return s(key, x)
+                        if (isOperator(key)) return (...y: X[]) => o(key, x, ...y)
+                        if (isFunction(key)) return (...y: X[]) => f(key, x, ...y)
+                        return toVar(x)('')
+                },
+                set(_, key, value) {
+                        if (isSwizzle(key)) {
+                                s(key, x).assign(value)
+                                return true
                         }
-
-                return callback?.({ path: [key], args: [] })
-        }
-        const apply = (_target: unknown, _thisArg: unknown, args: any) => {
-                return callback?.({ path: [], args })
-        }
-
-        return new Proxy(() => {}, { get, apply }) as X
+                        return false
+                },
+        }) as unknown as NodeProxy
+        return x
 }
 
-// スウィズルの戻り値型を取得
-const getSwizzleType = (swizzle: string): NodeType => {
-        if (swizzle.length === 1) return 'float'
-        if (swizzle.length === 2) return 'vec2'
-        if (swizzle.length === 3) return 'vec3'
-        if (swizzle.length === 4) return 'vec4'
-        return 'float'
-}
-
-// 数学関数の戻り値型を取得
-const getMathReturnType = (func: string, inputType: NodeType): NodeType => {
-        if (func === 'length') return 'float'
-        if (func === 'normalize') return inputType
-        if (func === 'toVar') return inputType
-        return inputType
-}
-
-// 公開API
-export const node = (type: NodeType, value?: any, options?: Partial<Node>) => {
-        const nodeInstance = createNode(type, value, options)
-        return createNodeProxy(nodeInstance)
-}
+// Node shorthands
+export const v = (...args: X[]) => node('variable', { id: getId() }, ...args)
+export const u = (key: string, defaultValue?: number | number[]) => node('uniform', { defaultValue }, key)
+export const s = (key: Swizzles, arg: X) => node('swizzle', null, key, arg)
+export const n = (key: string, ...args: X[]) => node('node_type', null, key, ...args)
+export const o = (key: Operators, ...args: X[]) => node('operator', null, key, ...args)
+export const f = (key: Functions, ...args: X[]) => node('math_fun', null, key, ...args)

package/src/node/scope.ts

@@ -0,0 +1,68 @@
+import { node } from './node'
+import { getId } from './utils'
+import type { NodeProxy, X } from './types'
+
+let _scope: NodeProxy | null = null
+
+const scoped = (x: NodeProxy | null, callback = () => {}) => {
+        const prev = _scope
+        _scope = x
+        callback()
+        _scope = prev
+}
+
+const addToScope = (x: NodeProxy) => {
+        if (!_scope) return // ignore
+        if (!_scope.props.children) _scope.props.children = []
+        _scope.props.children.push(x)
+}
+
+export const If = (x: X, callback: () => void) => {
+        const y = node('scope')
+        scoped(y, callback)
+        const ifNode = node('if', null, x, y)
+        addToScope(ifNode)
+        return {
+                ElseIf: (y: X, elseCallback: () => void) => {
+                        const z = node('scope')
+                        scoped(z, elseCallback)
+                        ifNode.props.children!.push(y, z)
+                },
+                Else: (elseCallback: () => void) => {
+                        const z = node('scope')
+                        scoped(z, elseCallback)
+                        ifNode.props.children!.push(z)
+                },
+        }
+}
+
+export const Loop = (x: X, callback?: (params: { i: NodeProxy }) => void) => {
+        const y = node('scope')
+        scoped(y, () => callback?.({ i: node('variable', { id: 'i' }) }))
+        const ret = node('loop', null, x, y)
+        addToScope(ret)
+        return ret
+}
+
+export const Fn = (callback: (args: X[]) => NodeProxy) => {
+        return (...args: X[]) => {
+                let result
+                const fnScope = node('scope')
+                scoped(fnScope, () => (result = callback(args)))
+                return node('fn', null, fnScope, result)
+        }
+}
+
+export const toVar = (x: X) => (id: string) => {
+        if (!id) id = getId()
+        const y = node('variable', { id })
+        const z = node('declare', null, y, x)
+        addToScope(z)
+        return y
+}
+
+export const assign = (x: X) => (y: X) => {
+        const assignNode = node('assign', null, x, y)
+        addToScope(assignNode)
+        return x
+}