glre 0.43.0 → 0.45.0

package/src/node/utils/const.ts

@@ -1,28 +1,7 @@
 export const SWIZZLES = ['x', 'y', 'z', 'w', 'r', 'g', 'b', 'a', 's', 't', 'p', 'q'] as const
 
 // Unified order with TYPE_MAPPING array
-export const CONVERSIONS = [
-        'toBool',
-        'toUInt',
-        'toInt',
-        'toFloat',
-        'toBVec2',
-        'toIVec2',
-        'toUVec2',
-        'toVec2',
-        'toBVec3',
-        'toIVec3',
-        'toUVec3',
-        'toVec3',
-        'toBVec4',
-        'toIVec4',
-        'toUVec4',
-        'toVec4',
-        'toColor',
-        'toMat2',
-        'toMat3',
-        'toMat4',
-] as const
+export const CONVERSIONS = ['toBool', 'toUInt', 'toInt', 'toFloat', 'toBVec2', 'toIVec2', 'toUVec2', 'toVec2', 'toBVec3', 'toIVec3', 'toUVec3', 'toVec3', 'toBVec4', 'toIVec4', 'toUVec4', 'toVec4', 'toColor', 'toMat2', 'toMat3', 'toMat4'] as const
 
 // Unified order with CONVERSIONS array
 export const TYPE_MAPPING = {
@@ -134,14 +113,7 @@ export const BUILTIN_TYPES = {
         color: 'vec4',
 } as const
 
-export const COMPARISON_OPERATORS = [
-        'equal',
-        'notEqual',
-        'lessThan',
-        'lessThanEqual',
-        'greaterThan',
-        'greaterThanEqual',
-] as const
+export const COMPARISON_OPERATORS = ['equal', 'notEqual', 'lessThan', 'lessThanEqual', 'greaterThan', 'greaterThanEqual'] as const
 
 export const LOGICAL_OPERATORS = ['and', 'or'] as const
 
@@ -270,9 +242,7 @@ const isSameType = (L: string, R: string): boolean => L === R
 
 // Check if combination exists in rules (handles bidirectional matching)
 const isValidCombination = (L: string, R: string): boolean => {
-        return OPERATOR_TYPE_RULES.some(
-                ([left, right, _]) => (left === L && right === R) || (left === R && right === L)
-        )
+        return OPERATOR_TYPE_RULES.some(([left, right, _]) => (left === L && right === R) || (left === R && right === L))
 }
 
 // Type constraint validation for operators ([L, R, Result] format)
@@ -287,8 +257,6 @@ export const getOperatorResultType = (L: string, R: string, op: string): string
         if (COMPARISON_OPERATORS.includes(op as any) || LOGICAL_OPERATORS.includes(op as any)) return 'bool'
         // Same type operations return the same type
         if (isSameType(L, R)) return L
-        const rule = OPERATOR_TYPE_RULES.find(
-                ([left, right, _]) => (left === L && right === R) || (left === R && right === L)
-        )
+        const rule = OPERATOR_TYPE_RULES.find(([left, right, _]) => (left === L && right === R) || (left === R && right === L))
         return rule ? rule[2] : L
 }

package/src/node/utils/index.ts

@@ -1,23 +1,6 @@
 import { infer } from './infer'
-import {
-        parseArray,
-        parseAttribHead,
-        parseConstantHead,
-        parseDeclare,
-        parseDefine,
-        parseGather,
-        parseIf,
-        parseLoop,
-        parseScatter,
-        parseStorageHead,
-        parseStruct,
-        parseStructHead,
-        parseSwitch,
-        parseTexture,
-        parseUniformHead,
-        parseVaryingHead,
-} from './parse'
-import { getBluiltin, getConversions, getOperator, initNodeContext, isElement, isX, setupEvent } from './utils'
+import { parseArray, parseAttribHead, parseConstantHead, parseDeclare, parseDefine, parseGather, parseIf, parseLoop, parseScatter, parseStorageHead, parseStruct, parseStructHead, parseSwitch, parseTexture, parseUniformHead, parseVaryingHead } from './parse'
+import { getBluiltin, getConversions, getOperator, initNodeContext, isX, setupEvent } from './utils'
 import { is } from '../../utils/helpers'
 import { mod } from '..'
 import type { Constants as C, NodeContext, Y } from '../types'
@@ -58,10 +41,7 @@ export const code = <T extends C>(target: Y<T>, c?: NodeContext | null): string
                         ? parseScatter(c, storageNode, y) // indexNode is not using
                         : `${code(storageNode, c)}[${code(indexNode, c)}] = ${code(y, c)};`
         }
-        if (type === 'ternary')
-                return c.isWebGL
-                        ? `(${code(z, c)} ? ${code(x, c)} : ${code(y, c)})`
-                        : `select(${code(x, c)}, ${code(y, c)}, ${code(z, c)})`
+        if (type === 'ternary') return c.isWebGL ? `(${code(z, c)} ? ${code(x, c)} : ${code(y, c)})` : `select(${code(x, c)}, ${code(y, c)}, ${code(z, c)})`
         if (type === 'conversion') return `${getConversions(x, c)}(${parseArray(children.slice(1), c)})`
         if (type === 'operator') {
                 if (x === 'not' || x === 'bitNot') return `!${code(y, c)}`
@@ -110,7 +90,7 @@ export const code = <T extends C>(target: Y<T>, c?: NodeContext | null): string
                 const field = parseVaryingHead(c, id, infer(target, c))
                 c.code?.fragInputs.set(id, field)
                 c.code?.vertOutputs.set(id, field)
-                c.code?.vertVaryings.set(id, code(x, c))
+                c.code?.vertVaryings.set(id, { node: x })
                 return c.isWebGL ? `${id}` : `out.${id}`
         }
         if (type === 'builtin') {

package/src/node/utils/utils.ts

@@ -1,14 +1,6 @@
-import {
-        CONSTANTS,
-        CONVERSIONS,
-        FUNCTIONS,
-        OPERATOR_KEYS,
-        OPERATORS,
-        TYPE_MAPPING,
-        WGSL_TO_GLSL_BUILTIN,
-} from './const'
+import { CONSTANTS, CONVERSIONS, FUNCTIONS, OPERATOR_KEYS, OPERATORS, TYPE_MAPPING, WGSL_TO_GLSL_BUILTIN } from './const'
 import { is } from '../../utils/helpers'
-import type { Constants as C, Conversions, Functions, NodeContext, Operators, Swizzles, X, Y } from '../types'
+import type { Constants as C, Conversions, Functions, NodeContext, Operators, Swizzles, VaryingInfo, X, Y } from '../types'
 import { storageSize } from '../../utils/program'
 
 export const isSwizzle = (key: unknown): key is Swizzles => {

package/src/types.ts

@@ -21,6 +21,7 @@ export type GL = EventState<{
         count: number
         instanceCount: number
         particleCount: number | [number, number] | [number, number, number]
+        precision: 'lowp' | 'mediump' | 'highp'
         loading: number
         el: HTMLCanvasElement
         vs?: string | Vec4
@@ -123,7 +124,7 @@ export interface WebGPUState {
  * for webgl
  */
 export interface WebGLState {
-        context: WebGLRenderingContext
+        context: WebGL2RenderingContext
         program: WebGLProgram
-        storages: any
+        uniforms: Nested<WebGLUniformLocation | null>
 }

package/src/utils/helpers.ts

@@ -94,7 +94,8 @@ export const getStride = (arrayLength: number, count = 1, error = console.warn)
 
 export const GLSL_FS = /* cpp */ `
 #version 300 es
-precision mediump float;
+precision highp float;
+precision highp int;
 out vec4 fragColor;
 uniform vec2 iResolution;
 void main() {

package/src/utils/program.ts

@@ -32,12 +32,7 @@ export const createArrayBuffer = (c: WebGL2RenderingContext, data: number[]) =>
         return { array, buffer }
 }
 
-export const setArrayBuffer = (
-        c: WebGL2RenderingContext,
-        array: Float32Array,
-        buffer: WebGLBuffer,
-        value: number[]
-) => {
+export const setArrayBuffer = (c: WebGL2RenderingContext, array: Float32Array, buffer: WebGLBuffer, value: number[]) => {
         array.set(value)
         c.bindBuffer(c.ARRAY_BUFFER, buffer)
         c.bufferData(c.ARRAY_BUFFER, array, c.STATIC_DRAW)
@@ -65,13 +60,7 @@ export const updateUniform = (c: WebGL2RenderingContext, loc: WebGLUniformLocati
         c[`uniformMatrix${l as 2}fv`](loc, false, value)
 }
 
-export const createTexture = (
-        c: WebGL2RenderingContext,
-        el: HTMLImageElement | HTMLVideoElement,
-        loc: WebGLUniformLocation,
-        unit: number,
-        isVideo = false
-) => {
+export const createTexture = (c: WebGL2RenderingContext, el: HTMLImageElement | HTMLVideoElement, loc: WebGLUniformLocation, unit: number, isVideo = false) => {
         const texture = c.createTexture()
         c.bindTexture(c.TEXTURE_2D, texture)
         c.texImage2D(c.TEXTURE_2D, 0, c.RGBA, c.RGBA, c.UNSIGNED_BYTE, el)
@@ -100,16 +89,7 @@ interface TextureBuffer {
         buffer: WebGLFramebuffer
 }
 
-export const createStorage = (
-        c: WebGL2RenderingContext,
-        value: number[],
-        width: number,
-        height: number,
-        ping: TextureBuffer,
-        pong: TextureBuffer,
-        unit: number,
-        array: Float32Array
-) => {
+export const createStorage = (c: WebGL2RenderingContext, value: number[], width: number, height: number, ping: TextureBuffer, pong: TextureBuffer, unit: number, array: Float32Array) => {
         const particleCount = width * height
         const vectorSize = value.length / particleCount
         for (let i = 0; i < particleCount; i++) {
@@ -132,10 +112,7 @@ export const createStorage = (
         c.texParameteri(c.TEXTURE_2D, c.TEXTURE_WRAP_T, c.CLAMP_TO_EDGE)
 }
 
-export const cleanStorage = (
-        c: WebGL2RenderingContext,
-        map: Iterable<{ ping: TextureBuffer; pong: TextureBuffer }>
-) => {
+export const cleanStorage = (c: WebGL2RenderingContext, map: Iterable<{ ping: TextureBuffer; pong: TextureBuffer }>) => {
         for (const { ping, pong } of map) {
                 c.deleteTexture(ping.texture)
                 c.deleteTexture(pong.texture)
@@ -144,14 +121,7 @@ export const cleanStorage = (
         }
 }
 
-export const createAttachment = (
-        c: WebGL2RenderingContext,
-        i: TextureBuffer,
-        o: TextureBuffer,
-        loc: WebGLUniformLocation,
-        unit: number,
-        index: number
-) => {
+export const createAttachment = (c: WebGL2RenderingContext, i: TextureBuffer, o: TextureBuffer, loc: WebGLUniformLocation, unit: number, index: number) => {
         c.activeTexture(c.TEXTURE0 + unit)
         c.bindTexture(c.TEXTURE_2D, i.texture)
         c.uniform1i(loc, unit)
@@ -168,19 +138,13 @@ export const storageSize = (particleCount: number | number[] = 1024) => {
         if (is.num(particleCount)) {
                 const sqrt = Math.sqrt(particleCount)
                 const size = Math.ceil(sqrt)
-                if (!Number.isInteger(sqrt)) {
-                        console.warn(
-                                `GLRE Storage Warning: particleCount (${particleCount}) is not a square. Using ${size}x${size} texture may waste GPU memory. Consider using [width, height] format for optimal storage.`
-                        )
-                }
+                if (!Number.isInteger(sqrt)) console.warn(`GLRE Storage Warning: particleCount (${particleCount}) is not a square. Using ${size}x${size} texture may waste GPU memory. Consider using [width, height] format for optimal storage.`)
                 return { x: size, y: size }
         }
         const [x, y, z] = particleCount
         if (z !== undefined) {
                 const yz = y * z
-                console.warn(
-                        `GLRE Storage Warning: 3D particleCount [${x}, ${y}, ${z}] specified but WebGL storage textures only support 2D. Flattening to 2D by multiplying height=${y} * depth=${z} = ${yz}.`
-                )
+                console.warn(`GLRE Storage Warning: 3D particleCount [${x}, ${y}, ${z}] specified but WebGL storage textures only support 2D. Flattening to 2D by multiplying height=${y} * depth=${z} = ${yz}.`)
                 return { x, y: yz }
         }
         return { x, y }

package/src/utils/webgl.ts

@@ -1,19 +1,7 @@
 import { nested as cached } from 'reev'
 import { is, getStride, GLSL_VS, GLSL_FS, loadingTexture } from './helpers'
-import {
-        createArrayBuffer,
-        cleanStorage,
-        createAttachment,
-        createProgram,
-        createStorage,
-        createTexture,
-        setArrayBuffer,
-        storageSize,
-        updateAttrib,
-        updateInstance,
-        updateUniform,
-} from './program'
-import type { GL, WebGLState } from '../types'
+import { createArrayBuffer, cleanStorage, createAttachment, createProgram, createStorage, createTexture, setArrayBuffer, storageSize, updateAttrib, updateInstance, updateUniform } from './program'
+import type { GL } from '../types'
 
 const computeProgram = (gl: GL, c: WebGL2RenderingContext) => {
         if (!gl.cs) return null // ignore if no compute shader
@@ -67,17 +55,17 @@ const computeProgram = (gl: GL, c: WebGL2RenderingContext) => {
 
 export const webgl = async (gl: GL) => {
         const config = { isWebGL: true, gl }
-        const c = gl.el!.getContext('webgl2')!
+        const c = (gl.webgl.context = gl.el!.getContext('webgl2')!)
         const cp = computeProgram(gl, c)
         const fs = gl.fs ? (is.str(gl.fs) ? gl.fs : gl.fs!.fragment(config)) : GLSL_FS
         const vs = gl.vs ? (is.str(gl.vs) ? gl.vs : gl.vs!.vertex(config)) : GLSL_VS
-        const pg = createProgram(c, fs, vs, gl)!
+        const pg = (gl.webgl.program = createProgram(c, fs, vs, gl)!)
         c.useProgram(pg)
 
         let activeUnit = 0 // for texture units
 
         const units = cached(() => activeUnit++)
-        const uniforms = cached((key) => c.getUniformLocation(pg, key))
+        const uniforms = (gl.webgl.uniforms = cached((key) => c.getUniformLocation(pg, key)))
 
         const attribs = cached((key, value: number[], isInstance = false) => {
                 const stride = getStride(value.length, isInstance ? gl.instanceCount : gl.count, gl.error)
@@ -143,7 +131,5 @@ export const webgl = async (gl: GL) => {
                 ext.polygonModeWEBGL(c.FRONT_AND_BACK, ext.LINE_WEBGL)
         }
 
-        const webgl: WebGLState = { context: c, program: pg, storages: cp?.storages }
-
-        return { webgl, render, clean, _attribute, _instance, _uniform, _texture, _storage: cp?._storage }
+        return { render, clean, _attribute, _instance, _uniform, _texture, _storage: cp?._storage }
 }