glre 0.33.0 → 0.35.0

package/src/node/types.ts

@@ -1,4 +1,5 @@
 import { GL } from '../types'
+
 import { CONSTANTS, CONVERSIONS, FUNCTIONS, OPERATOR_KEYS } from './const'
 
 export type Constants = (typeof CONSTANTS)[number] | 'void'
@@ -47,17 +48,17 @@ export type NodeTypes =
         | 'declare'
         | 'return'
 
-export interface NodeProps {
+export interface NodeProps<T extends Record<string, NodeProxy> = {}> {
         id?: string
-        args?: X[]
+        args?: any[]
         type?: string
-        children?: X[]
-        inferFrom?: X[]
+        children?: any[]
+        inferFrom?: any[]
         layout?: FnLayout
         parent?: NodeProxy
         // for struct
-        fields?: Record<string, NodeProxy>
-        initialValues?: Record<string, NodeProxy>
+        fields?: T
+        initialValues?: T
 }
 
 export interface NodeContext {
@@ -78,7 +79,48 @@ export interface NodeContext {
 }
 
 /**
- * NodeProxy
+ * infer
+ */
+// Unified logic with infer.ts inferOperator function
+// prettier-ignore
+type InferOperator<L extends Constants, R extends Constants> =
+        L extends R ? L :
+        // broadcast
+        L extends 'float' | 'int' ? R :
+        R extends 'float' | 'int' ? L :
+        // mat * vec → vec
+        L extends 'mat4' ? R extends 'vec4' ? R /* default */ : L :
+        L extends 'mat3' ? R extends 'vec3' ? R /* default */ : L :
+        L extends 'mat2' ? R extends 'vec2' ? R /* default */ : L :
+        // vec * mat → vec
+        L extends 'vec4' ? R extends 'mat4' ? L /* default */ : L :
+        L extends 'vec3' ? R extends 'mat3' ? L /* default */ : L :
+        L extends 'vec2' ? R extends 'mat2' ? L /* default */ : L : L
+
+type _StringLength<S extends string> = S extends `${infer _}${infer Rest}`
+        ? Rest extends ''
+                ? 1
+                : Rest extends `${infer _}${infer Rest2}`
+                ? Rest2 extends ''
+                        ? 2
+                        : Rest2 extends `${infer _}${infer Rest3}`
+                        ? Rest3 extends ''
+                                ? 3
+                                : 4
+                        : never
+                : never
+        : 0
+
+type InferSwizzleType<S extends string> = _StringLength<S> extends 4
+        ? 'vec4'
+        : _StringLength<S> extends 3
+        ? 'vec3'
+        : _StringLength<S> extends 2
+        ? 'vec2'
+        : 'float'
+
+/**
+ * Swizzles
  */
 type _Swizzles<T extends string> = T | `${T}${T}` | `${T}${T}${T}` | `${T}${T}${T}${T}`
 
@@ -101,14 +143,10 @@ type NodeProxyMethods =
         | 'toVar'
         | 'toString'
 
-export type ReadNodeProxy = {
-        [K in string as K extends NodeProxyMethods ? never : K]: X
-}
-
-export interface BaseNodeProxy extends Record<Swizzles, NodeProxy> {
+export interface BaseNodeProxy<T extends Constants> {
         // System properties
-        assign(n: X): NodeProxy
-        toVar(name?: string): NodeProxy
+        assign(x: any): NodeProxy<T>
+        toVar(name?: string): NodeProxy<T>
         toString(c?: NodeContext): string
         type: NodeTypes
         props: NodeProps
@@ -116,90 +154,176 @@ export interface BaseNodeProxy extends Record<Swizzles, NodeProxy> {
         listeners: Set<(value: any) => void>
 
         // Operators methods
-        add(n: X): NodeProxy
-        sub(n: X): NodeProxy
-        mul(n: X): NodeProxy
-        div(n: X): NodeProxy
-        mod(n: X): NodeProxy
-        equal(n: X): NodeProxy
-        notEqual(n: X): NodeProxy
-        lessThan(n: X): NodeProxy
-        lessThanEqual(n: X): NodeProxy
-        greaterThan(n: X): NodeProxy
-        greaterThanEqual(n: X): NodeProxy
-        and(n: X): NodeProxy
-        or(n: X): NodeProxy
-        not(): NodeProxy
-
-        // Conversations methods
-        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
-
-        // Function methods
-        abs(): NodeProxy
-        sin(): NodeProxy
-        cos(): NodeProxy
-        tan(): NodeProxy
-        asin(): NodeProxy
-        acos(): NodeProxy
-        atan(): NodeProxy
-        atan2(x: X): NodeProxy
-        pow(y: X): NodeProxy
-        pow2(): NodeProxy
-        pow3(): NodeProxy
-        pow4(): NodeProxy
-        sqrt(): NodeProxy
-        inverseSqrt(): NodeProxy
-        exp(): NodeProxy
-        exp2(): NodeProxy
-        log(): NodeProxy
-        log2(): NodeProxy
-        floor(): NodeProxy
-        ceil(): NodeProxy
-        round(): NodeProxy
-        fract(): NodeProxy
-        trunc(): NodeProxy
-        min(y: X): NodeProxy
-        max(y: X): NodeProxy
-        clamp(min: X, max: X): NodeProxy
-        saturate(): NodeProxy
-        mix(y: X, a: X): NodeProxy
-        step(edge: X): NodeProxy
-        smoothstep(edge0: X, edge1: X): NodeProxy
-        length(): NodeProxy
-        distance(y: X): NodeProxy
-        dot(y: X): NodeProxy
-        cross(y: X): NodeProxy
-        normalize(): NodeProxy
-        reflect(N: X): NodeProxy
-        refract(N: X, eta: X): NodeProxy
-        sign(): NodeProxy
-        oneMinus(): NodeProxy
-        reciprocal(): NodeProxy
-        negate(): NodeProxy
-        dFdx(): NodeProxy
-        dFdy(): NodeProxy
-        fwidth(): NodeProxy
+        add<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        sub<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        mul<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        div<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        mod<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        equal<U extends Constants>(x: X<U>): Bool
+        notEqual<U extends Constants>(x: X<U>): Bool
+        lessThan<U extends Constants>(x: X<U>): Bool
+        lessThanEqual<U extends Constants>(x: X<U>): Bool
+        greaterThan<U extends Constants>(x: X<U>): Bool
+        greaterThanEqual<U extends Constants>(x: X<U>): Bool
+        and(x: X<'bool'>): Bool
+        or(x: X<'bool'>): Bool
+        not(): Bool
+
+        // Bitwise operators
+        bitAnd(x: X<T>): NodeProxy<T>
+        bitOr(x: X<T>): NodeProxy<T>
+        bitXor(x: X<T>): NodeProxy<T>
+        bitNot(): NodeProxy<T>
+        shiftLeft<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        shiftRight<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+
+        // Conversion methods
+        toBool(): Bool
+        toUint(): UInt
+        toInt(): Int
+        toFloat(): Float
+        toBvec2(): BVec2
+        toIvec2(): IVec2
+        toUvec2(): UVec2
+        toVec2(): Vec2
+        toBvec3(): BVec3
+        toIvec3(): IVec3
+        toUvec3(): UVec3
+        toVec3(): Vec3
+        toBvec4(): BVec4
+        toIvec4(): IVec4
+        toUvec4(): UVec4
+        toVec4(): Vec4
+        toColor(): Color
+        toMat2(): Mat2
+        toMat3(): Mat3
+        toMat4(): Mat4
+
+        // Mathematical function methods (preserve type functions)
+        abs(): NodeProxy<T>
+        sign(): NodeProxy<T>
+        floor(): NodeProxy<T>
+        ceil(): NodeProxy<T>
+        round(): NodeProxy<T>
+        fract(): NodeProxy<T>
+        trunc(): NodeProxy<T>
+        sin(): NodeProxy<T>
+        cos(): NodeProxy<T>
+        tan(): NodeProxy<T>
+        asin(): NodeProxy<T>
+        acos(): NodeProxy<T>
+        atan(): NodeProxy<T>
+        exp(): NodeProxy<T>
+        exp2(): NodeProxy<T>
+        log(): NodeProxy<T>
+        log2(): NodeProxy<T>
+        sqrt(): NodeProxy<T>
+        inverseSqrt(): NodeProxy<T>
+        normalize(): NodeProxy<T>
+        oneMinus(): NodeProxy<T>
+        saturate(): NodeProxy<T>
+        negate(): NodeProxy<T>
+        reciprocal(): NodeProxy<T>
+        dFdx(): NodeProxy<T>
+        dFdy(): NodeProxy<T>
+        fwidth(): NodeProxy<T>
+
+        // Scalar return functions
+        length(): Float
+        lengthSq(): Float
+        determinant(): Float
+        luminance(): Float
+
+        // Bool return functions
+        all(): Bool
+        any(): Bool
+
+        // Specific return type functions
+        cross<U extends Constants>(y: X<U>): Vec3
+
+        // Two argument functions with variable return types
+        atan2<U extends Constants>(x: X<U>): NodeProxy<T>
+        pow<U extends Constants>(y: X<U>): NodeProxy<T>
+        distance<U extends Constants>(y: X<U>): Float
+        dot<U extends Constants>(y: X<U>): Float
+        reflect<U extends Constants>(N: X<U>): NodeProxy<T>
+        refract<U extends Constants>(N: X<U>, eta: any): NodeProxy<T>
+
+        // Multi-argument functions that return highest priority type
+        min<U extends Constants>(y: X<U>): NodeProxy<InferOperator<T, U>>
+        max<U extends Constants>(y: X<U>): NodeProxy<InferOperator<T, U>>
+        mix<U extends Constants, V>(y: X<U>, a: V): NodeProxy<InferOperator<T, U>>
+        clamp<U extends Constants, V>(mix: X<U>, max: V): NodeProxy<InferOperator<T, U>>
+        step<U extends Constants>(edge: X<U>): NodeProxy<InferOperator<T, U>>
+        smoothstep<U extends Constants, V>(edge0: X<U>, edge1: V): NodeProxy<InferOperator<T, U>>
+
+        // Power functions
+        pow2(): NodeProxy<T>
+        pow3(): NodeProxy<T>
+        pow4(): NodeProxy<T>
+}
+
+type ReadNodeProxy = {
+        [K in string as K extends NodeProxyMethods ? never : K]: any
+} & {
+        [K in Swizzles]: NodeProxy<InferSwizzleType<K>>
+}
+
+// Internal NodeProxy implementation (renamed from original)
+type NodeProxyImpl<T extends Constants = string> = BaseNodeProxy<T> & ReadNodeProxy
+
+export type Bool = NodeProxyImpl<'bool'>
+export type UInt = NodeProxyImpl<'uint'>
+export type Int = NodeProxyImpl<'int'>
+export type Float = NodeProxyImpl<'float'>
+export type BVec2 = NodeProxyImpl<'bvec2'>
+export type IVec2 = NodeProxyImpl<'ivec2'>
+export type UVec2 = NodeProxyImpl<'uvec2'>
+export type Vec2 = NodeProxyImpl<'vec2'>
+export type BVec3 = NodeProxyImpl<'bvec3'>
+export type IVec3 = NodeProxyImpl<'ivec3'>
+export type UVec3 = NodeProxyImpl<'uvec3'>
+export type Vec3 = NodeProxyImpl<'vec3'>
+export type BVec4 = NodeProxyImpl<'bvec4'>
+export type IVec4 = NodeProxyImpl<'ivec4'>
+export type UVec4 = NodeProxyImpl<'uvec4'>
+export type Vec4 = NodeProxyImpl<'vec4'>
+export type Color = NodeProxyImpl<'color'>
+export type Mat2 = NodeProxyImpl<'mat2'>
+export type Mat3 = NodeProxyImpl<'mat3'>
+export type Mat4 = NodeProxyImpl<'mat4'>
+export type Texture = NodeProxyImpl<'texture'>
+export type Sampler2D = NodeProxyImpl<'sampler2D'>
+export type Struct = NodeProxyImpl<'struct'>
+
+export interface ConstantsToType {
+        bool: Bool
+        uint: UInt
+        int: Int
+        float: Float
+        bvec2: BVec2
+        ivec2: IVec2
+        uvec2: UVec2
+        vec2: Vec2
+        bvec3: BVec3
+        ivec3: IVec3
+        uvec3: UVec3
+        vec3: Vec3
+        bvec4: BVec4
+        ivec4: IVec4
+        uvec4: UVec4
+        vec4: Vec4
+        color: Color
+        mat2: Mat2
+        mat3: Mat3
+        mat4: Mat4
+        texture: Texture
+        sampler2D: Sampler2D
+        struct: Struct
 }
 
-export type NodeProxy = BaseNodeProxy & ReadNodeProxy
+export type NodeProxy<T extends Constants = string> = T extends keyof ConstantsToType
+        ? ConstantsToType[T]
+        : NodeProxyImpl<T>
 
-export type X = X[] | (NodeProxy | number | string | boolean | undefined)
+export type X<T extends Constants = string> = number | string | boolean | undefined | NodeProxy<T> | X[]

package/src/node/utils.ts

@@ -26,7 +26,7 @@ export const isConversion = (key: unknown): key is Conversions => {
         return CONVERSIONS.includes(key as Conversions)
 }
 
-export const isNodeProxy = (x: unknown): x is NodeProxy => {
+export const isNodeProxy = <T extends Constants>(x: unknown): x is NodeProxy<T> => {
         if (!x) return false
         if (typeof x !== 'object') return false // @ts-ignore
         return x.isProxy
@@ -46,15 +46,15 @@ export const hex2rgb = (hex: number) => {
 
 let count = 0
 
-export const getId = () => `i${count++}`
+export const getId = () => `x${count++}`
 
-export const formatConversions = (x: X, c?: NodeContext) => {
+export const formatConversions = <T extends Constants>(x: X<T>, c?: NodeContext) => {
         if (!is.str(x)) return ''
         if (c?.isWebGL) return x
         return TYPE_MAPPING[x as keyof typeof TYPE_MAPPING] || x // for struct type
 }
 
-export const getOperator = (op: X) => {
+export const getOperator = (op: X<string>) => {
         return OPERATORS[op as keyof typeof OPERATORS] || op
 }
 
@@ -78,8 +78,8 @@ export const getEventFun = (c: NodeContext, id: string, isAttribute = false, isT
         return (value: any) => c.gl?._uniform?.(id, value)
 }
 
-export const safeEventCall = (x: X, fun: (value: unknown) => void) => {
-        if (!x) return
+export const safeEventCall = <T extends Constants>(x: X<T>, fun: (value: unknown) => void) => {
+        if (is.und(x)) return
         if (!isNodeProxy(x)) return fun(x) // for uniform(1)
         if (x.type !== 'conversion') return
         const value = x.props.children?.slice(1).filter(Boolean)

package/src/types.ts

@@ -1,6 +1,6 @@
 import type { EventState, Nested } from 'reev'
 import type { Fun, Queue, Frame } from 'refr'
-import type { NodeProxy } from './node'
+import type { NodeProxy, Vec4 } from './node'
 export type { Fun, Queue, Frame }
 export type PrecisionMode = 'highp' | 'mediump' | 'lowp'
 export type GLClearMode = 'COLOR_BUFFER_BIT' | 'DEPTH_BUFFER_BIT' | 'STENCIL_BUFFER_BIT'
@@ -59,20 +59,22 @@ export type GL = EventState<{
          */
         isNative: boolean
         isWebGL: boolean
+        isError: boolean
         isLoop: boolean
         isGL: true
-        width: number
-        height: number
+        width?: number
+        height?: number
         size: [number, number]
         mouse: [number, number]
         count: number
+        loading: number
         el: HTMLCanvasElement
-        vs: string | NodeProxy
-        fs: string | NodeProxy
-        vert: string | NodeProxy
-        frag: string | NodeProxy
-        vertex: string | NodeProxy
-        fragment: string | NodeProxy
+        vs?: string | Vec4
+        fs?: string | Vec4
+        vert?: string | Vec4
+        frag?: string | Vec4
+        vertex?: string | Vec4
+        fragment?: string | Vec4
 
         /**
          * core state
@@ -86,13 +88,13 @@ export type GL = EventState<{
          * events
          */
         ref?: any
-        init(): void
-        loop(): void
         mount(): void
         clean(): void
+        error(e?: string): void
         render(): void
         resize(e?: Event): void
         mousemove(e: Event): void
+        loop(): void
 
         /**
          * setter

package/src/utils/program.ts

@@ -1,27 +1,26 @@
-const createShader = (c: WebGLRenderingContext, source: string, type: number) => {
+const createShader = (c: WebGLRenderingContext, source: string, type: number, onError = console.warn) => {
         const shader = c.createShader(type)
-        if (!shader) throw new Error('Failed to create shader')
+        if (!shader) return onError('Failed to create shader')
         c.shaderSource(shader, source.trim())
         c.compileShader(shader)
         if (c.getShaderParameter(shader, c.COMPILE_STATUS)) return shader
         const error = c.getShaderInfoLog(shader)
         c.deleteShader(shader)
-        console.warn(`Could not compile shader: ${error}`)
+        onError(`Could not compile shader: ${error}`)
 }
 
-export const createProgram = (c: WebGLRenderingContext, vert: string, frag: string, onError = () => {}) => {
+export const createProgram = (c: WebGLRenderingContext, vert: string, frag: string, onError = console.warn) => {
         const pg = c.createProgram()
-        const fs = createShader(c, frag, c.FRAGMENT_SHADER)
-        const vs = createShader(c, vert, c.VERTEX_SHADER)
-        if (!fs || !vs) return onError()
-        c.attachShader(pg, vs)
-        c.attachShader(pg, fs)
+        const fs = createShader(c, frag, c.FRAGMENT_SHADER, onError)
+        const vs = createShader(c, vert, c.VERTEX_SHADER, onError)
+        if (!fs || !vs) 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)
-        onError()
-        console.warn(`Could not link program: ${error}`)
+        onError(`Could not link program: ${error}`)
 }
 
 export const createVbo = (c: WebGLRenderingContext, data: number[]) => {

package/src/webgl.ts

@@ -4,24 +4,29 @@ import { is } from './utils/helpers'
 import { createAttrib, createIbo, createProgram, createTexture, createVbo, getStride } from './utils/program'
 import type { GL, WebGLState } from './types'
 
-export const webgl = async (gl: Partial<GL>) => {
+export const webgl = async (gl: GL) => {
         const c = gl.el!.getContext('webgl2')!
         const config = { isWebGL: true, gl }
         const fs = fragment(gl.fs, config)
         const vs = vertex(gl.vs, config)
-        const pg = createProgram(c, vs, fs, () => void (gl.isLoop = false))!
+        const pg = createProgram(c, vs, fs, gl.error)!
         c.useProgram(pg)
 
-        let _activeUnit = 0
+        let activeUnit = 0
         const uniforms = cached((key) => c.getUniformLocation(pg, key))
         const attribs = cached((key) => c.getAttribLocation(pg, key))
-        const units = cached(() => _activeUnit++)
+        const units = cached(() => activeUnit++)
 
-        const clean = () => c.deleteProgram(pg)
+        const clean = () => {
+                c.deleteProgram(pg)
+                c.getExtension('WEBGL_lose_context')?.loseContext()
+                gl.el.width = 1
+                gl.el.height = 1
+        }
 
         const render = () => {
                 c.clear(c.COLOR_BUFFER_BIT)
-                c.viewport(0, 0, ...gl.size!)
+                c.viewport(0, 0, ...gl.size)
                 c.drawArrays(c.TRIANGLES, 0, 3)
         }
 
@@ -29,7 +34,7 @@ export const webgl = async (gl: Partial<GL>) => {
                 const loc = attribs(key, true)
                 const vbo = createVbo(c, value)
                 const ibo = createIbo(c, iboValue)
-                const str = getStride(gl.count!, value, iboValue)
+                const str = getStride(gl.count, value, iboValue)
                 createAttrib(c, str, loc, vbo, ibo)
         }
 
@@ -43,14 +48,18 @@ export const webgl = async (gl: Partial<GL>) => {
         }
 
         const _texture = (key: string, src: string) => {
+                gl.loading++
                 const image = new Image()
                 Object.assign(image, { src, crossOrigin: 'anonymous' })
                 image.decode().then(() => {
                         const loc = uniforms(key)
                         const unit = units(key)
                         createTexture(c, image, loc, unit)
+                        gl.loading--
                 })
         }
 
-        return { render, clean, _attribute, _uniform, _texture, webgl: { context: c, program: pg } as WebGLState }
+        const webgl: WebGLState = { context: c, program: pg }
+
+        return { webgl, render, clean, _attribute, _uniform, _texture }
 }

package/src/webgpu.ts

@@ -15,14 +15,14 @@ import {
 import type { GL, WebGPUState } from './types'
 import { fragment, vertex } from './node'
 
-export const webgpu = async (gl: Partial<GL>) => {
+export const webgpu = async (gl: GL) => {
         const context = gl.el!.getContext('webgpu') as GPUCanvasContext
         const { device, format } = await createDevice(context)
+        device.onuncapturederror = (e) => gl.error(e.error.message)
         const bindings = createBindings()
         let frag: string
         let vert: string
         let flush = (_pass: GPURenderPassEncoder) => {}
-        let imageLoading = 0
         let needsUpdate = true
         let depthTexture: GPUTexture
 
@@ -42,7 +42,7 @@ export const webgpu = async (gl: Partial<GL>) => {
 
         const attribs = cached((_key, value: number[]) => {
                 needsUpdate = true
-                const stride = value.length / gl.count!
+                const stride = value.length / gl.count
                 const { location } = bindings.attrib()
                 const { array, buffer } = createAttribBuffer(device, value)
                 return { array, buffer, location, stride }
@@ -60,7 +60,7 @@ export const webgpu = async (gl: Partial<GL>) => {
                         pass.setPipeline(pipeline)
                         bindGroups.forEach((v, i) => pass.setBindGroup(i, v))
                         vertexBuffers.forEach((v, i) => pass.setVertexBuffer(i, v))
-                        pass.draw(gl.count!, 1, 0, 0)
+                        pass.draw(gl.count, 1, 0, 0)
                         pass.end()
                 }
         }
@@ -71,7 +71,7 @@ export const webgpu = async (gl: Partial<GL>) => {
                         frag = fragment(gl.fs, config)
                         vert = vertex(gl.vs, config)
                 }
-                if (imageLoading) return // MEMO: loading after build node
+                if (gl.loading) return // MEMO: loading after build node
                 if (needsUpdate) update()
                 needsUpdate = false
                 const encoder = device.createCommandEncoder()
@@ -86,7 +86,11 @@ export const webgpu = async (gl: Partial<GL>) => {
         }
 
         const clean = () => {
+                device.destroy()
                 depthTexture?.destroy()
+                for (const { texture } of textures.map.values()) texture.destroy()
+                for (const { buffer } of uniforms.map.values()) buffer.destroy()
+                for (const { buffer } of attribs.map.values()) buffer.destroy()
         }
 
         const _attribute = (key = '', value: number[]) => {
@@ -103,13 +107,13 @@ export const webgpu = async (gl: Partial<GL>) => {
         }
 
         const _texture = (key: string, src: string) => {
-                imageLoading++
+                gl.loading++
                 const source = Object.assign(new Image(), { src, crossOrigin: 'anonymous' })
                 source.decode().then(() => {
                         const { width, height } = source
                         const { texture } = textures(key, width, height)
                         device.queue.copyExternalImageToTexture({ source }, { texture }, { width, height })
-                        imageLoading--
+                        gl.loading--
                 })
         }