glre 0.26.0 → 0.27.0

package/src/utils/pipeline.ts

@@ -1,5 +1,4 @@
-import { wgsl } from '../code/wgsl'
-import { X } from '../node'
+import { fragment, vertex, X } from '../node'
 import { is } from './helpers'
 import type { GPUContext, GPUDevice, GPUPipeline } from '../types'
 
@@ -21,7 +20,7 @@ fn main(@builtin(position) position: vec4f) -> @location(0) vec4f {
 }
 `
 
-export const createDevive = async (c: GPUContext) => {
+export const createDevice = async (c: GPUContext) => {
         const gpu = (navigator as any).gpu
         const format = gpu.getPreferredCanvasFormat()
         const adapter = await gpu.requestAdapter()
@@ -38,8 +37,8 @@ export const createPipeline = (
         vs: string | X = defaultVertexWGSL,
         fs: string | X = defaultFragmentWGSL
 ) => {
-        if (is.obj(fs)) fs = wgsl(fs)
-        if (is.obj(vs)) vs = wgsl(vs)
+        if (!is.str(fs)) fs = fragment(fs, { isWebGL: false })
+        if (!is.str(vs)) vs = vertex(vs, { isWebGL: false })
         const layout = device.createPipelineLayout({ bindGroupLayouts })
         return device.createRenderPipeline({
                 vertex: {

package/src/utils/program.ts

@@ -1,5 +1,4 @@
-import { glsl } from '../code/glsl'
-import { X } from '../node'
+import { fragment, vertex, X } from '../node'
 import { is } from './helpers'
 
 export const defaultVertexGLSL = /* cpp */ `
@@ -29,7 +28,7 @@ const createShader = (c: WebGLRenderingContext, source: string, type: number) =>
         if (c.getShaderParameter(shader, c.COMPILE_STATUS)) return shader
         const error = c.getShaderInfoLog(shader)
         c.deleteShader(shader)
-        throw new Error(`Could not compile shader: ${error}`)
+        console.warn(`Could not compile shader: ${error}`)
 }
 
 export const createProgram = (
@@ -37,16 +36,19 @@ export const createProgram = (
         vs: string | X = defaultVertexGLSL,
         fs: string | X = defaultFragmentGLSL
 ) => {
-        if (is.obj(fs)) fs = glsl(fs as X)
-        if (is.obj(vs)) vs = glsl(vs as X)
+        if (!is.str(fs)) fs = fragment(fs, { isWebGL: true })
+        if (!is.str(vs)) vs = vertex(fs, { isWebGL: true })
         const pg = c.createProgram()
-        c.attachShader(pg, createShader(c, vs, c.VERTEX_SHADER))
-        c.attachShader(pg, createShader(c, fs, c.FRAGMENT_SHADER))
+        const _vs = createShader(c, vs, c.VERTEX_SHADER)
+        const _fs = createShader(c, fs, c.FRAGMENT_SHADER)
+        if (!_vs || !_fs) return
+        c.attachShader(pg, _vs)
+        c.attachShader(pg, _fs)
         c.linkProgram(pg)
         if (c.getProgramParameter(pg, c.LINK_STATUS)) return pg
         const error = c.getProgramInfoLog(pg)
         c.deleteProgram(pg)
-        throw new Error(`Could not link pg: ${error}`)
+        console.warn(`Could not link pg: ${error}`)
 }
 
 export const createVbo = (c: WebGLRenderingContext, data: number[]) => {

package/src/webgl.ts

@@ -5,7 +5,7 @@ import type { GL, WebGLState } from './types'
 
 export const webgl = async (gl: Partial<GL>) => {
         const c = gl.el!.getContext('webgl2')!
-        const pg = createProgram(c, gl.vs, gl.fs)
+        const pg = createProgram(c, gl.vs, gl.fs)!
         const state = { context: c, program: pg } as WebGLState
         c.useProgram(pg)
 

package/src/webgpu.ts

@@ -1,7 +1,7 @@
 import { nested as cached } from 'reev'
 import { is } from './utils/helpers'
 import {
-        createDevive,
+        createDevice,
         createPipeline,
         createDescriptor,
         createUniformBuffer,
@@ -14,7 +14,7 @@ import type { GL, WebGPUState } from './types'
 
 export const webgpu = async (gl: Partial<GL>) => {
         const c = gl.el!.getContext('webgpu') as any
-        const { device, format } = await createDevive(c)
+        const { device, format } = await createDevice(c)
         const state = {
                 device,
                 context: c,

package/src/code/glsl.ts

@@ -1,148 +0,0 @@
-import { is } from './../utils/helpers'
-import type { Node, NodeType, X, ConversionContext } from '../node'
-
-// GLSLコード生成コンテキスト
-interface GLSLContext extends ConversionContext {
-        target: 'webgl'
-        precision: 'lowp' | 'mediump' | 'highp'
-        version: '100' | '300 es'
-}
-
-// ノードからGLSLコードを生成
-export const nodeToGLSL = (nodeProxy: X, context?: Partial<GLSLContext>): string => {
-        const ctx: GLSLContext = {
-                target: 'webgl',
-                precision: 'mediump',
-                version: '300 es',
-                nodes: new Map(),
-                variables: new Map(),
-                functions: new Map(),
-                ...context,
-        }
-
-        return generateGLSLExpression(nodeProxy as any, ctx)
-}
-
-// GLSL式を生成
-const generateGLSLExpression = (node: Node, context: GLSLContext): string => {
-        if (!node) return '0.0'
-        // 値ノード
-        if (!is.und(node.value)) return formatGLSLValue(node.value, node.type)
-        // プロパティアクセス（スウィズル）
-        if (node.property && node.parent) {
-                const parentExpr = generateGLSLExpression(node.parent, context)
-                return `${parentExpr}.${node.property}`
-        }
-        // 演算子ノード
-        if (node.operator && node.children && node.children.length >= 2) return generateGLSLOperator(node, context)
-        // 数学関数ノード
-        if (node.mathFunction && node.children && node.children.length >= 1)
-                return generateGLSLMathFunction(node, context)
-        return '0.0'
-}
-
-// GLSL値をフォーマット
-const formatGLSLValue = (value: any, type: NodeType): string => {
-        if (type === 'float') {
-                const num = Number(value)
-                return num % 1 === 0 ? `${num}.0` : `${num}`
-        }
-        if (type === 'int') return `${Math.floor(Number(value))}`
-        if (type === 'bool') return Boolean(value) ? 'true' : 'false'
-        if (is.arr(value)) {
-                const values = value
-                        .map((v) => {
-                                const num = Number(v)
-                                return num % 1 === 0 ? `${num}.0` : `${num}`
-                        })
-                        .join(', ')
-                if (type === 'vec2') return `vec2(${values})`
-                if (type === 'vec3') return `vec3(${values})`
-                if (type === 'vec4') return `vec4(${values})`
-                if (type === 'color') return `vec3(${values})`
-        }
-        return '0.0'
-}
-
-// GLSL演算子を生成
-const generateGLSLOperator = (node: Node, context: GLSLContext): string => {
-        if (!node.children || node.children.length < 2) return '0.0'
-        const left = generateGLSLExpression(node.children[0], context)
-        const right = generateGLSLExpression(node.children[1], context)
-        if (node.operator === 'add') return `(${left} + ${right})`
-        if (node.operator === 'sub') return `(${left} - ${right})`
-        if (node.operator === 'mul') return `(${left} * ${right})`
-        if (node.operator === 'div') return `(${left} / ${right})`
-        if (node.operator === 'mod') return `mod(${left}, ${right})`
-        if (node.operator === 'equal') return `(${left} == ${right})`
-        if (node.operator === 'notEqual') return `(${left} != ${right})`
-        if (node.operator === 'lessThan') return `(${left} < ${right})`
-        if (node.operator === 'lessThanEqual') return `(${left} <= ${right})`
-        if (node.operator === 'greaterThan') return `(${left} > ${right})`
-        if (node.operator === 'greaterThanEqual') return `(${left} >= ${right})`
-        if (node.operator === 'and') return `(${left} && ${right})`
-        if (node.operator === 'or') return `(${left} || ${right})`
-        return `(${left} + ${right})`
-}
-
-// GLSL数学関数を生成
-const generateGLSLMathFunction = (node: Node, context: GLSLContext): string => {
-        if (!node.children || node.children.length < 1) return '0.0'
-        const fun = node.mathFunction
-        const args = node.children.map((child) => {
-                return generateGLSLExpression(child, context)
-        })
-        const [x, y, z] = args
-        // @TODO FIX
-        // if (fun === 'toVar') return x // toVarは変数化のヒントなので、そのまま返す
-        if (args.length === 1) return `${fun}(${x})`
-        if (args.length === 2) return `${fun}(${x}, ${y})`
-        if (args.length === 3) return `${fun}(${x}, ${y}, ${z})`
-        return x || '0.0'
-}
-
-// 値からGLSL型を推定
-const inferGLSLType = (value: unknown): string => {
-        if (is.num(value)) return 'float'
-        if (is.bol(value)) return 'bool'
-        if (is.arr(value)) {
-                const len = value.length
-                if (len === 2) return 'vec2'
-                if (len === 3) return 'vec3'
-                if (len === 4) return 'vec4'
-        }
-        return 'float'
-}
-
-// 完全なGLSLシェーダーを生成
-export const glsl = (
-        fragmentNode: X,
-        options?: {
-                precision?: 'lowp' | 'mediump' | 'highp'
-                version?: '100' | '300 es'
-                uniforms?: Record<string, any>
-        }
-) => {
-        const precision = options?.precision || 'mediump'
-        const version = options?.version || '300 es'
-        const is300ES = version === '300 es'
-        const fragment = nodeToGLSL(fragmentNode)
-        let shader = ''
-        if (is300ES) shader += '#version 300 es\n'
-        shader += `precision ${precision} float;\n\n`
-        // ユニフォーム変数の追加
-        if (options?.uniforms) {
-                Object.entries(options.uniforms).forEach(([name, value]) => {
-                        const type = inferGLSLType(value)
-                        shader += `uniform ${type} ${name};\n`
-                })
-                shader += '\n'
-        }
-        // 出力変数
-        if (is300ES) shader += 'out vec4 fragColor;\n\n'
-        shader += 'void main() {\n'
-        shader += is300ES ? `    fragColor = ${fragment};\n` : `    gl_FragColor = ${fragment};\n`
-        shader += '}\n'
-
-        return shader
-}

package/src/code/wgsl.ts

@@ -1,134 +0,0 @@
-import { is } from '../utils/helpers'
-import type { Node, NodeType, ConversionContext, X } from '../node'
-
-// WGSLコード生成コンテキスト
-interface WGSLContext extends ConversionContext {
-        target: 'webgpu'
-}
-
-// ノードからWGSLコードを生成
-export const nodeToWGSL = (nodeProxy: X, context?: Partial<WGSLContext>): string => {
-        const ctx: WGSLContext = {
-                target: 'webgpu',
-                nodes: new Map(),
-                variables: new Map(),
-                functions: new Map(),
-                ...context,
-        }
-        return generateWGSLExpression(nodeProxy as any, ctx)
-}
-
-// WGSL式を生成
-const generateWGSLExpression = (node: Node, context: WGSLContext): string => {
-        if (!node) return '0.0'
-        // 値ノード
-        if (node.value !== undefined) return formatWGSLValue(node.value, node.type)
-        // プロパティアクセス（スウィズル）
-        if (node.property && node.parent) {
-                const parentExpr = generateWGSLExpression(node.parent, context)
-                return `${parentExpr}.${node.property}`
-        }
-        // 演算子ノード
-        if (node.operator && node.children && node.children.length >= 2) return generateWGSLOperator(node, context)
-        // 数学関数ノード
-        if (node.mathFunction && node.children && node.children.length >= 1)
-                return generateWGSLMathFunction(node, context)
-        return '0.0'
-}
-
-// WGSL値をフォーマット
-const formatWGSLValue = (value: any, type: NodeType): string => {
-        if (type === 'float') {
-                const num = Number(value)
-                return num % 1 === 0 ? `${num}.0` : `${num}`
-        }
-        if (type === 'int') return `${Math.floor(Number(value))}`
-        if (type === 'bool') return Boolean(value) ? 'true' : 'false'
-        if (is.arr(value)) {
-                const values = value
-                        .map((v) => {
-                                const num = Number(v)
-                                return num % 1 === 0 ? `${num}.0` : `${num}`
-                        })
-                        .join(', ')
-                if (type === 'vec2') return `vec2<f32>(${values})`
-                if (type === 'vec3') return `vec3<f32>(${values})`
-                if (type === 'vec4') return `vec4<f32>(${values})`
-                if (type === 'color') return `vec3<f32>(${values})`
-        }
-
-        return '0.0'
-}
-
-// WGSL演算子を生成
-const generateWGSLOperator = (node: Node, context: WGSLContext): string => {
-        if (!node.children || node.children.length < 2) return '0.0'
-        const left = generateWGSLExpression(node.children[0], context)
-        const right = generateWGSLExpression(node.children[1], context)
-        if (node.operator === 'add') return `(${left} + ${right})`
-        if (node.operator === 'sub') return `(${left} - ${right})`
-        if (node.operator === 'mul') return `(${left} * ${right})`
-        if (node.operator === 'div') return `(${left} / ${right})`
-        if (node.operator === 'mod') return `(${left} % ${right})`
-        if (node.operator === 'equal') return `(${left} == ${right})`
-        if (node.operator === 'notEqual') return `(${left} != ${right})`
-        if (node.operator === 'lessThan') return `(${left} < ${right})`
-        if (node.operator === 'lessThanEqual') return `(${left} <= ${right})`
-        if (node.operator === 'greaterThan') return `(${left} > ${right})`
-        if (node.operator === 'greaterThanEqual') return `(${left} >= ${right})`
-        if (node.operator === 'and') return `(${left} && ${right})`
-        if (node.operator === 'or') return `(${left} || ${right})`
-        return `(${left} + ${right})`
-}
-
-// WGSL数学関数を生成
-const generateWGSLMathFunction = (node: Node, context: WGSLContext): string => {
-        if (!node.children || node.children.length < 1) return '0.0'
-        const fun = node.mathFunction
-        const args = node.children.map((child) => generateWGSLExpression(child, context))
-        const [x, y, z] = args
-        // @TODO FIX
-        // if (fun === 'toVar') return x // toVarは変数化のヒントなので、そのまま返す
-        if (args.length === 1) return `${fun}(${x})`
-        if (args.length === 2) return `${fun}(${x}, ${y})`
-        if (args.length === 3) return `${fun}(${x}, ${y}, ${z})`
-        return x || '0.0'
-}
-
-// 完全なWGSLシェーダーを生成
-export const wgsl = (
-        fragmentNode: X,
-        options?: {
-                uniforms?: Record<string, any>
-        }
-) => {
-        let shader = ''
-        // ユニフォーム変数の追加
-        if (options?.uniforms) {
-                Object.entries(options.uniforms).forEach(([name, value]) => {
-                        const type = inferWGSLType(value)
-                        shader += `@group(0) @binding(0) var<uniform> ${name}: ${type};\n`
-                })
-                shader += '\n'
-        }
-        shader += '@fragment\n'
-        shader += 'fn main() -> @location(0) vec4<f32> {\n'
-        const fragmentExpr = nodeToWGSL(fragmentNode)
-        shader += `    return ${fragmentExpr};\n`
-        shader += '}\n'
-
-        return shader
-}
-
-// 値からWGSL型を推定
-const inferWGSLType = (value: any): string => {
-        if (is.num(value)) return 'f32'
-        if (is.bol(value)) return 'bool'
-        if (is.arr(value)) {
-                const len = value.length
-                if (len === 2) return 'vec2<f32>'
-                if (len === 3) return 'vec3<f32>'
-                if (len === 4) return 'vec4<f32>'
-        }
-        return 'f32'
-}

package/src/node/cache.ts

@@ -1,60 +0,0 @@
-import { CACHE_BOOLS, CACHE_INTS, CACHE_FLOATS } from './const'
-import { node } from '.'
-import type { X } from './types'
-
-const boolCache = new Map<boolean, X>()
-const intCache = new Map<number, X>()
-const floatCache = new Map<number, X>()
-
-const initializeCache = () => {
-        CACHE_BOOLS.forEach((value) => {
-                boolCache.set(value, node('bool', value))
-        })
-        CACHE_INTS.forEach((value) => {
-                intCache.set(value, node('int', value))
-        })
-        CACHE_FLOATS.forEach((value) => {
-                floatCache.set(value, node('float', value))
-        })
-}
-
-export const getCachedBool = (x: boolean): X => {
-        if (!boolCache.has(x)) initializeCache()
-        return boolCache.get(x) || node('bool', x)
-}
-
-// キャッシュされたintノードを取得
-export const getCachedInt = (x: number): X => {
-        if (intCache.has(x)) return intCache.get(x)!
-        return node('int', x)
-}
-
-// キャッシュされたfloatノードを取得
-export const getCachedFloat = (x: number): X => {
-        if (floatCache.has(x)) return floatCache.get(x)!
-        return node('float', x)
-}
-
-// ノードの重複を検出
-export const findDuplicateNodes = (nodes: X[]): Map<string, X[]> => {
-        const duplicates = new Map<string, X[]>()
-        const signatures = new Map<string, X>()
-
-        nodes.forEach((nodeProxy) => {
-                const signature = generateNodeSignature(nodeProxy)
-                if (signatures.has(signature)) {
-                        if (!duplicates.has(signature)) duplicates.set(signature, [signatures.get(signature)!])
-                        duplicates.get(signature)!.push(nodeProxy)
-                } else signatures.set(signature, nodeProxy)
-        })
-        return duplicates
-}
-
-// ノードのシグネチャを生成
-const generateNodeSignature = (nodeProxy: X): string => {
-        const parts = [nodeProxy.type, `${nodeProxy.value}`, nodeProxy.property || '']
-        return parts.join('|')
-}
-
-// 初期化を実行
-// initializeCache()

package/src/node/conv.ts

@@ -1,111 +0,0 @@
-import { node } from '.'
-import { getCachedBool, getCachedInt, getCachedFloat } from './cache'
-import { is } from '../utils/helpers'
-import type { X } from './types'
-
-// JavaScript値をノードに変換
-export const convertToNode = (x: unknown): X => {
-        if (is.bol(x)) return getCachedBool(x)
-        if (is.num(x)) {
-                if (is.int(x)) return getCachedInt(x)
-                return getCachedFloat(x)
-        }
-        if (is.arr(x)) return convertArrayToNode(x)
-        if (is.obj(x)) return convertObjectToNode(x)
-        return node('float', 0)
-}
-
-// 配列をベクトル/行列ノードに変換
-const convertArrayToNode = (array: number[]): X => {
-        const len = array.length
-        if (len === 2) return node('vec2', array)
-        if (len === 3) return node('vec3', array)
-        if (len === 4) return node('vec4', array)
-        if (len === 9) return node('mat3', array)
-        if (len === 16) return node('mat4', array)
-        return node('float', array[0])
-}
-
-// オブジェクトをノードに変換
-const convertObjectToNode = (obj: any): X => {
-        // カラーオブジェクトの検出
-        if ('r' in obj && 'g' in obj && 'b' in obj) {
-                const arr = [obj.r, obj.g, obj.b]
-                if ('a' in obj) arr.push(obj.a)
-                return node('color', arr)
-        }
-        // ベクトルライクオブジェクトの検出
-        if ('x' in obj && 'y' in obj) {
-                const arr = [obj.x, obj.y]
-                if ('z' in obj) arr.push(obj.z)
-                if ('w' in obj) arr.push(obj.w)
-                return convertArrayToNode(arr)
-        }
-        return node('float', 0)
-}
-
-// 型変換関数
-export const float = (x: unknown): X => {
-        if (is.num(x)) return getCachedFloat(x)
-        return node('float', Number(x))
-}
-
-export const int = (x: unknown): X => {
-        if (is.num(x) && Number.isInteger(x)) return getCachedInt(x)
-        return node('int', Math.floor(Number(x)))
-}
-
-export const bool = (x: unknown): X => {
-        return getCachedBool(Boolean(x))
-}
-
-export const vec2 = (x?: any, y?: any): X => {
-        if (is.und(x)) return node('vec2', [0, 0])
-        if (is.und(y)) {
-                if (is.arr(x)) return node('vec2', x.slice(0, 2))
-                if (is.obj(x) && 'x' in x && 'y' in x) return node('vec2', [x.x, x.y])
-                return node('vec2', [Number(x), Number(x)])
-        }
-        return node('vec2', [Number(x), Number(y)])
-}
-
-export const vec3 = (x?: any, y?: any, z?: any): X => {
-        if (is.und(x)) return node('vec3', [0, 0, 0])
-        if (is.und(y)) {
-                if (is.arr(x)) return node('vec3', x.slice(0, 3))
-                if (is.obj(x) && 'x' in x && 'y' in x && 'z' in x) return node('vec3', [x.x, x.y, x.z])
-                return node('vec3', [Number(x), Number(x), Number(x)])
-        }
-        if (z === undefined) {
-                return node('vec3', [Number(x), Number(y), 0])
-        }
-        return node('vec3', [Number(x), Number(y), Number(z)])
-}
-
-export const vec4 = (x?: any, y?: any, z?: any, w?: any): X => {
-        if (is.und(x)) return node('vec4', [0, 0, 0, 1])
-        if (is.und(y)) {
-                if (is.arr(x)) return node('vec4', x.slice(0, 4))
-                if (is.obj(x) && 'x' in x && 'y' in x && 'z' in x && 'w' in x) return node('vec4', [x.x, x.y, x.z, x.w])
-                return node('vec4', [Number(x), Number(x), Number(x), 1])
-        }
-        return node('vec4', [Number(x), Number(y), Number(z), Number(w)])
-}
-
-export const color = (r?: any, g?: any, b?: any): X => {
-        if (r === undefined) return node('color', [1, 1, 1])
-
-        // 16進数カラーの処理
-        if (is.str(r) && r.startsWith('#')) {
-                const hex = r.slice(1)
-                const num = parseInt(hex, 16)
-                return node('color', [((num >> 16) & 255) / 255, ((num >> 8) & 255) / 255, (num & 255) / 255])
-        }
-
-        // 数値カラーの処理
-        if (is.num(r) && g === undefined && b === undefined) {
-                return node('color', [((r >> 16) & 255) / 255, ((r >> 8) & 255) / 255, (r & 255) / 255])
-        }
-
-        return vec3(r, g, b)
-}

package/src/node/uniform.ts

@@ -1,92 +0,0 @@
-import { node } from './node'
-import { is } from '../utils/helpers'
-import type { UniformNode } from './types'
-import type { NodeType } from './const'
-
-// ユニフォーム更新コンテキスト
-interface UpdateContext {
-        object?: any
-        camera?: any
-        renderer?: any
-        scene?: any
-        time?: number
-}
-
-// ユニフォーム値の型を推定
-const inferUniformType = (value: any): NodeType => {
-        if (is.num(value)) return 'float'
-        if (is.bol(value)) return 'bool'
-        if (is.arr(value)) {
-                const len = value.length
-                if (len === 2) return 'vec2'
-                if (len === 3) return 'vec3'
-                if (len === 4) return 'vec4'
-                if (len === 9) return 'mat3'
-                if (len === 16) return 'mat4'
-        }
-        if (is.obj(value) && 'r' in value && 'g' in value && 'b' in value) return 'color'
-        return 'float'
-}
-
-// ユニフォーム変数を作成
-export const uniform = (initialValue: any): UniformNode => {
-        const type = inferUniformType(initialValue)
-        let currentValue = initialValue
-        let objectUpdateCallback: ((context: UpdateContext) => any) | null = null
-        let renderUpdateCallback: ((context: UpdateContext) => any) | null = null
-
-        const baseNode = node(type, currentValue) as any
-
-        // 値を設定
-        const set = (value: any) => {
-                currentValue = value
-                baseNode.value = value
-        }
-        // オブジェクト更新時のコールバックを設定
-        const onObjectUpdate = (callback: (context: UpdateContext) => any): UniformNode => {
-                objectUpdateCallback = callback
-                return uniformNode
-        }
-        // レンダー更新時のコールバックを設定
-        const onRenderUpdate = (callback: (context: UpdateContext) => any): UniformNode => {
-                renderUpdateCallback = callback
-                return uniformNode
-        }
-        // 内部更新関数（外部から呼び出される）
-        const _updateFromContext = (context: UpdateContext) => {
-                if (objectUpdateCallback) {
-                        const newValue = objectUpdateCallback(context)
-                        if (newValue !== undefined) set(newValue)
-                }
-                if (renderUpdateCallback) {
-                        const newValue = renderUpdateCallback(context)
-                        if (newValue !== undefined) set(newValue)
-                }
-        }
-        // UniformNodeインターフェースを実装
-        const uniformNode = Object.create(baseNode)
-        uniformNode.set = set
-        uniformNode.onObjectUpdate = onObjectUpdate
-        uniformNode.onRenderUpdate = onRenderUpdate
-        uniformNode._updateFromContext = _updateFromContext
-        uniformNode.isUniform = true
-        return uniformNode as UniformNode
-}
-
-// 組み込みユニフォーム変数
-export const iTime = uniform(0.0)
-export const iPrevTime = uniform(0.0)
-export const iDeltaTime = uniform(0.0)
-export const iResolution = uniform([1920, 1080])
-export const iMouse = uniform([0, 0])
-
-// ユニフォーム変数の更新（レンダーループで呼び出される）
-export const updateUniforms = (context: UpdateContext) => {
-        // 時間の更新
-        if (context.time !== undefined) {
-                const prevTime = iTime.value || 0
-                iTime.set(context.time)
-                iPrevTime.set(prevTime)
-                iDeltaTime.set(context.time - prevTime)
-        }
-}