glre 0.29.0 → 0.31.0

package/src/node/types.ts

@@ -8,12 +8,22 @@ export type Functions = (typeof FUNCTIONS)[number]
 
 export type Operators = (typeof OPERATOR_KEYS)[number]
 
+export interface FnLayout {
+        name: string
+        type: Constants | 'auto'
+        inputs?: Array<{
+                name: string
+                type: Constants
+        }>
+}
+
 export interface NodeProps {
         id?: string
         args?: X[]
         type?: string
         children?: X[]
-        value?: number | number[] | boolean
+        inferFrom?: X
+        layout?: FnLayout
 }
 
 export interface NodeConfig {
@@ -21,7 +31,7 @@ export interface NodeConfig {
         binding?: number
         infers?: WeakMap<NodeProxy, Constants>
         headers?: Map<string, string>
-        onMount?: (name: string, value: any) => void
+        onMount?: (name: string) => void
 }
 
 type _Swizzles<T extends string> = T | `${T}${T}` | `${T}${T}${T}` | `${T}${T}${T}${T}`
@@ -33,26 +43,29 @@ export type Swizzles =
         | _Swizzles<'s' | 't'>
 
 export type NodeTypes =
+        // headers
+        | 'attribute'
         | 'uniform'
+        | 'varying'
+        | 'constant'
+        // variables
         | 'variable'
         | 'swizzle'
-        | 'operator'
+        | 'ternary'
+        | 'builtin'
         | 'conversion'
+        | 'operator'
         | 'function'
-        | 'declare'
+        // scopes
+        | 'scope'
         | 'assign'
+        | 'loop'
         | 'define'
         | 'if'
-        | 'loop'
-        | 'scope'
         | 'switch'
-        | 'ternary'
-        | 'attribute'
-        | 'varying'
-        | 'builtin'
-        | 'constant'
+        | 'declare'
 
-export interface NodeProxy extends Record<Swizzles | Conversions, NodeProxy> {
+export interface NodeProxy extends Record<Swizzles, NodeProxy> {
         // Operators
         add(n: X): NodeProxy
         sub(n: X): NodeProxy
@@ -72,7 +85,6 @@ export interface NodeProxy extends Record<Swizzles | Conversions, NodeProxy> {
         // Variable manipulation
         assign(n: X): NodeProxy
         toVar(name?: string): NodeProxy
-        toConst(name?: string): NodeProxy
 
         // Math function methods
         abs(): NodeProxy
@@ -121,6 +133,26 @@ export interface NodeProxy extends Record<Swizzles | Conversions, NodeProxy> {
         fwidth(): NodeProxy
 
         // System properties
+        toBool(): NodeProxy
+        toUint(): NodeProxy
+        toInt(): NodeProxy
+        toFloat(): NodeProxy
+        toBvec2(): NodeProxy
+        toIvec2(): NodeProxy
+        toUvec2(): NodeProxy
+        toVec2(): NodeProxy
+        toBvec3(): NodeProxy
+        toIvec3(): NodeProxy
+        toUvec3(): NodeProxy
+        toVec3(): NodeProxy
+        toBvec4(): NodeProxy
+        toIvec4(): NodeProxy
+        toUvec4(): NodeProxy
+        toVec4(): NodeProxy
+        toColor(): NodeProxy
+        toMat2(): NodeProxy
+        toMat3(): NodeProxy
+        toMat4(): NodeProxy
         toString(c?: NodeConfig): string
         type: NodeTypes
         props: NodeProps

package/src/node/utils.ts

@@ -1,9 +1,26 @@
-import { NodeProps } from './../../../../node_modules/glre/src/node/types'
 import { is } from '../utils/helpers'
 import { code } from './code'
-import { CONVERSIONS, FUNCTIONS, OPERATOR_KEYS, OPERATORS, TYPE_MAPPING } from './const'
-import type { Conversions, Functions, NodeConfig, NodeProxy, Operators, Swizzles, X } from './types'
 import { infer } from './infer'
+import {
+        CONSTANTS,
+        CONVERSIONS,
+        FUNCTIONS,
+        OPERATOR_KEYS,
+        OPERATORS,
+        TYPE_MAPPING,
+        WGSL_TO_GLSL_BUILTIN,
+} from './const'
+import type {
+        Constants,
+        Conversions,
+        Functions,
+        NodeConfig,
+        NodeProps,
+        NodeProxy,
+        Operators,
+        Swizzles,
+        X,
+} from './types'
 
 export const isSwizzle = (key: unknown): key is Swizzles => {
         return is.str(key) && /^[xyzwrgbastpq]{1,4}$/.test(key)
@@ -27,8 +44,6 @@ export const isNodeProxy = (x: unknown): x is NodeProxy => {
         return x.isProxy
 }
 
-let count = 0
-
 export const hex2rgb = (hex: number) => {
         const r = ((hex >> 16) & 0xff) / 255
         const g = ((hex >> 8) & 0xff) / 255
@@ -36,6 +51,8 @@ export const hex2rgb = (hex: number) => {
         return [r, g, b]
 }
 
+let count = 0
+
 export const getId = () => `i${count++}`
 
 export const joins = (children: X[], c: NodeConfig) => {
@@ -55,6 +72,15 @@ export const getOperator = (op: X) => {
         return OPERATORS[op as keyof typeof OPERATORS] || op
 }
 
+export const getBluiltin = (id: string) => {
+        return WGSL_TO_GLSL_BUILTIN[id as keyof typeof WGSL_TO_GLSL_BUILTIN]
+}
+
+export const conversionToConstant = (conversionKey: string): Constants => {
+        const index = CONVERSIONS.indexOf(conversionKey as Conversions)
+        return index !== -1 ? CONSTANTS[index] : 'float'
+}
+
 const generateHead = (c: NodeConfig) => {
         return Array.from(c.headers!)
                 .map(([, v]) => v)
@@ -62,37 +88,61 @@ const generateHead = (c: NodeConfig) => {
 }
 
 export const generateDefine = (props: NodeProps, c: NodeConfig) => {
-        const { id, children = [] } = props
+        const { id, children = [], layout } = props
         const [x, y, ...args] = children
-        const returnType = y ? infer(y, c) : 'void'
-        const params = args.map((arg, i) => [`p${i}`, infer(arg, c)])
-        const lines = [code(x, c)]
-        if (y) lines.push(`return ${code(y, c)};`)
+        const returnType = layout?.type && layout?.type !== 'auto' ? layout?.type : y ? infer(y, c) : 'void'
+        const argParams: [name: string, type: string][] = []
+        const params: string[] = []
+        if (layout?.inputs)
+                for (const input of layout.inputs) {
+                        argParams.push([input.name, input.type])
+                }
+        else
+                for (let i = 0; i < args.length; i++) {
+                        argParams.push([`p${i}`, infer(args[i], c)])
+                }
+        let ret = ''
         if (c?.isWebGL) {
-                const paramList = params.map(([name, type]) => `${type} ${name}`)
-                return `${returnType} ${id}(${paramList}) {\n${lines.join('\n')}\n}`
+                for (const [id, type] of argParams) params.push(`${type} ${id}`)
+                ret += `${returnType} ${id}(${params}) {\n`
+        } else {
+                for (const [id, type] of argParams) params.push(`${id}: ${formatConversions(type, c)}`)
+                ret += `fn ${id}(${params}) -> ${formatConversions(returnType, c)} {\n`
         }
-        const wgslReturnType = formatConversions(returnType, c)
-        const wgslParams = params.map(([name, type]) => `${name}: ${formatConversions(type, c)}`)
-        return `fn ${id}(${wgslParams}) -> ${wgslReturnType} {\n${lines.join('\n')}\n}`
+        const scopeCode = code(x, c)
+        if (scopeCode) ret += scopeCode + '\n'
+        if (y) ret += `return ${code(y, c)};`
+        ret += '\n}'
+        return ret
 }
 
-const generateFragmentMain = (body: string, head: string, isWebGL = true) => {
-        if (isWebGL)
-                return `
+const GLSL_FRAGMENT_HEAD = `
 #version 300 es
 precision mediump float;
 out vec4 fragColor;
-${head}
-void main() {
-fragColor = ${body};
-}`.trim()
-        return `
-${head}
+`.trim()
+
+const WGSL_FRAGMENT_HEAD = `
 @fragment
 fn main(@builtin(position) position: vec4f) -> @location(0) vec4f {
-return ${body};
-}`.trim()
+`.trim()
+
+const generateFragmentMain = (body: string, head: string, isWebGL = true) => {
+        let ret = ''
+        if (isWebGL) ret += GLSL_FRAGMENT_HEAD
+        if (head) ret += '\n' + head + '\n'
+        if (isWebGL) ret += `void main() {\n  fragColor = ${body};`
+        else {
+                ret += WGSL_FRAGMENT_HEAD + '\n'
+                ret += `  return ${body};`
+        }
+        ret += '\n}'
+        return ret
+}
+
+const generateVertexMain = (_body: string, _head: string, isWebGL = true) => {
+        if (isWebGL) return ``
+        return ``
 }
 
 export const fragment = (x: X, c: NodeConfig = {}) => {
@@ -106,5 +156,5 @@ export const fragment = (x: X, c: NodeConfig = {}) => {
 export const vertex = (x: X, c: NodeConfig) => {
         const body = code(x, c)
         const head = generateHead(c)
-        return generateFragmentMain(body, head, c.isWebGL)
+        return generateVertexMain(body, head, c.isWebGL)
 }