glre 0.43.0 → 0.44.0

package/dist/react.d.ts

@@ -121,14 +121,64 @@ interface NodeContext {
 /**
  * infer
  */
-type _StringLength<A extends string> = A extends `${infer _}${infer A}` ? A extends '' ? 1 : A extends `${infer _}${infer B}` ? B extends '' ? 2 : B extends `${infer _}${infer C}` ? C extends '' ? 3 : 4 : never : never : never;
 type InferOperator<L extends C, R extends C> = L extends R ? L : L extends 'float' | 'int' ? R : R extends 'float' | 'int' ? L : L extends 'mat4' ? R extends 'vec4' ? R : L : L extends 'mat3' ? R extends 'vec3' ? R : L : L extends 'mat2' ? R extends 'vec2' ? R : L : L extends 'vec4' ? R extends 'mat4' ? L : L : L extends 'vec3' ? R extends 'mat3' ? L : L : L extends 'vec2' ? R extends 'mat2' ? L : L : L;
 type InferArrayElement<T extends C> = T extends 'mat4' ? 'vec4' : T extends 'mat3' ? 'vec3' : T extends 'mat2' ? 'vec2' : 'float';
+type _OperatorTypeRulesMap = typeof OPERATOR_TYPE_RULES;
 type ExtractPairs<T> = T extends readonly [infer L, infer R, string] ? [L, R] | [R, L] : never;
-type OperatorTypeRules = ExtractPairs<(typeof OPERATOR_TYPE_RULES)[number]>;
+type OperatorTypeRules = ExtractPairs<_OperatorTypeRulesMap[number]>;
 type IsInRules<L extends C, R extends C> = [L, R] extends OperatorTypeRules ? 1 : 0;
 type ValidateOperator<L extends C, R extends C> = L extends R ? 1 : IsInRules<L, R>;
-type InferSwizzleType<S extends string> = _StringLength<S> extends 4 ? 'vec4' : _StringLength<S> extends 3 ? 'vec3' : _StringLength<S> extends 2 ? 'vec2' : 'float';
+/**
+ * swizzle
+ */
+type _SwizzleLength<A extends string> = A extends `${infer _}${infer A}` ? A extends '' ? 1 : A extends `${infer _}${infer B}` ? B extends '' ? 2 : B extends `${infer _}${infer C}` ? C extends '' ? 3 : 4 : never : never : never;
+type _SwizzleBaseMap = {
+    float: 'float';
+    vec2: 'float';
+    vec3: 'float';
+    vec4: 'float';
+    int: 'int';
+    ivec2: 'int';
+    ivec3: 'int';
+    ivec4: 'int';
+    uint: 'uint';
+    uvec2: 'uint';
+    uvec3: 'uint';
+    uvec4: 'uint';
+    bool: 'bool';
+    bvec2: 'bool';
+    bvec3: 'bool';
+    bvec4: 'bool';
+};
+type _SwizzleResultMap = {
+    float: {
+        1: 'float';
+        2: 'vec2';
+        3: 'vec3';
+        4: 'vec4';
+    };
+    int: {
+        1: 'int';
+        2: 'ivec2';
+        3: 'ivec3';
+        4: 'ivec4';
+    };
+    uint: {
+        1: 'uint';
+        2: 'uvec2';
+        3: 'uvec3';
+        4: 'uvec4';
+    };
+    bool: {
+        1: 'bool';
+        2: 'bvec2';
+        3: 'bvec3';
+        4: 'bvec4';
+    };
+};
+type _SwizzleBase<T extends C> = T extends keyof _SwizzleBaseMap ? _SwizzleBaseMap[T] : never;
+type _SwizzleResult<T extends C, L extends 1 | 2 | 3 | 4> = _SwizzleResultMap[_SwizzleBase<T>][L];
+type InferSwizzleType<T extends C, S extends string> = _SwizzleLength<S> extends infer L extends 1 | 2 | 3 | 4 ? _SwizzleResult<_SwizzleBase<T>, L> : never;
 /**
  * Swizzles
  */
@@ -190,7 +240,7 @@ interface ConstantsToType {
 type XImpl<T extends C> = _X<T> & {
     [K in string as K extends Methods ? never : K]: any;
 } & {
-    [K in Swizzles]: X<InferSwizzleType<K>>;
+    [K in Swizzles]: X<InferSwizzleType<T, K>>;
 };
 type C = Constants;
 type X<T extends C = C> = T extends keyof ConstantsToType ? ConstantsToType[T] : _X<T>;
@@ -270,7 +320,7 @@ interface _X<T extends C> {
     any(): Bool;
     determinant(): T extends 'mat2' | 'mat3' | 'mat4' ? Float : never;
     distance<U extends C>(y: T extends 'vec2' | 'vec3' | 'vec4' ? (U extends T ? number | X<U> : never) : never): Float;
-    dot<U extends C>(y: T extends 'vec2' | 'vec3' | 'vec4' | 'ivec2' | 'ivec3' | 'ivec4' ? U extends T ? number | X<U> : never : never): T extends `ivec${string}` ? Int : Float;
+    dot<U extends C>(y: T extends 'vec2' | 'vec3' | 'vec4' | 'ivec2' | 'ivec3' | 'ivec4' ? (U extends T ? number | X<U> : never) : never): T extends `ivec${string}` ? Int : Float;
     length(): T extends 'vec2' | 'vec3' | 'vec4' ? Float : never;
     lengthSq(): Float;
     luminance(): Float;
@@ -350,6 +400,7 @@ 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;
@@ -452,9 +503,9 @@ interface WebGPUState {
  * for webgl
  */
 interface WebGLState {
-    context: WebGLRenderingContext;
+    context: WebGL2RenderingContext;
     program: WebGLProgram;
-    storages: any;
+    uniforms: Nested<WebGLUniformLocation | null>;
 }
 
 declare const isGL: (a: unknown) => a is EventState<GL>;
@@ -476,6 +527,7 @@ declare const createGL: (props?: Partial<GL>) => EventState<{
     count: number;
     instanceCount: number;
     particleCount: number | [number, number] | [number, number, number];
+    precision: "lowp" | "mediump" | "highp";
     loading: number;
     el: HTMLCanvasElement;
     vs?: string | Vec4;

package/dist/solid.d.ts

@@ -121,14 +121,64 @@ interface NodeContext {
 /**
  * infer
  */
-type _StringLength<A extends string> = A extends `${infer _}${infer A}` ? A extends '' ? 1 : A extends `${infer _}${infer B}` ? B extends '' ? 2 : B extends `${infer _}${infer C}` ? C extends '' ? 3 : 4 : never : never : never;
 type InferOperator<L extends C, R extends C> = L extends R ? L : L extends 'float' | 'int' ? R : R extends 'float' | 'int' ? L : L extends 'mat4' ? R extends 'vec4' ? R : L : L extends 'mat3' ? R extends 'vec3' ? R : L : L extends 'mat2' ? R extends 'vec2' ? R : L : L extends 'vec4' ? R extends 'mat4' ? L : L : L extends 'vec3' ? R extends 'mat3' ? L : L : L extends 'vec2' ? R extends 'mat2' ? L : L : L;
 type InferArrayElement<T extends C> = T extends 'mat4' ? 'vec4' : T extends 'mat3' ? 'vec3' : T extends 'mat2' ? 'vec2' : 'float';
+type _OperatorTypeRulesMap = typeof OPERATOR_TYPE_RULES;
 type ExtractPairs<T> = T extends readonly [infer L, infer R, string] ? [L, R] | [R, L] : never;
-type OperatorTypeRules = ExtractPairs<(typeof OPERATOR_TYPE_RULES)[number]>;
+type OperatorTypeRules = ExtractPairs<_OperatorTypeRulesMap[number]>;
 type IsInRules<L extends C, R extends C> = [L, R] extends OperatorTypeRules ? 1 : 0;
 type ValidateOperator<L extends C, R extends C> = L extends R ? 1 : IsInRules<L, R>;
-type InferSwizzleType<S extends string> = _StringLength<S> extends 4 ? 'vec4' : _StringLength<S> extends 3 ? 'vec3' : _StringLength<S> extends 2 ? 'vec2' : 'float';
+/**
+ * swizzle
+ */
+type _SwizzleLength<A extends string> = A extends `${infer _}${infer A}` ? A extends '' ? 1 : A extends `${infer _}${infer B}` ? B extends '' ? 2 : B extends `${infer _}${infer C}` ? C extends '' ? 3 : 4 : never : never : never;
+type _SwizzleBaseMap = {
+    float: 'float';
+    vec2: 'float';
+    vec3: 'float';
+    vec4: 'float';
+    int: 'int';
+    ivec2: 'int';
+    ivec3: 'int';
+    ivec4: 'int';
+    uint: 'uint';
+    uvec2: 'uint';
+    uvec3: 'uint';
+    uvec4: 'uint';
+    bool: 'bool';
+    bvec2: 'bool';
+    bvec3: 'bool';
+    bvec4: 'bool';
+};
+type _SwizzleResultMap = {
+    float: {
+        1: 'float';
+        2: 'vec2';
+        3: 'vec3';
+        4: 'vec4';
+    };
+    int: {
+        1: 'int';
+        2: 'ivec2';
+        3: 'ivec3';
+        4: 'ivec4';
+    };
+    uint: {
+        1: 'uint';
+        2: 'uvec2';
+        3: 'uvec3';
+        4: 'uvec4';
+    };
+    bool: {
+        1: 'bool';
+        2: 'bvec2';
+        3: 'bvec3';
+        4: 'bvec4';
+    };
+};
+type _SwizzleBase<T extends C> = T extends keyof _SwizzleBaseMap ? _SwizzleBaseMap[T] : never;
+type _SwizzleResult<T extends C, L extends 1 | 2 | 3 | 4> = _SwizzleResultMap[_SwizzleBase<T>][L];
+type InferSwizzleType<T extends C, S extends string> = _SwizzleLength<S> extends infer L extends 1 | 2 | 3 | 4 ? _SwizzleResult<_SwizzleBase<T>, L> : never;
 /**
  * Swizzles
  */
@@ -190,7 +240,7 @@ interface ConstantsToType {
 type XImpl<T extends C> = _X<T> & {
     [K in string as K extends Methods ? never : K]: any;
 } & {
-    [K in Swizzles]: X<InferSwizzleType<K>>;
+    [K in Swizzles]: X<InferSwizzleType<T, K>>;
 };
 type C = Constants;
 type X<T extends C = C> = T extends keyof ConstantsToType ? ConstantsToType[T] : _X<T>;
@@ -270,7 +320,7 @@ interface _X<T extends C> {
     any(): Bool;
     determinant(): T extends 'mat2' | 'mat3' | 'mat4' ? Float : never;
     distance<U extends C>(y: T extends 'vec2' | 'vec3' | 'vec4' ? (U extends T ? number | X<U> : never) : never): Float;
-    dot<U extends C>(y: T extends 'vec2' | 'vec3' | 'vec4' | 'ivec2' | 'ivec3' | 'ivec4' ? U extends T ? number | X<U> : never : never): T extends `ivec${string}` ? Int : Float;
+    dot<U extends C>(y: T extends 'vec2' | 'vec3' | 'vec4' | 'ivec2' | 'ivec3' | 'ivec4' ? (U extends T ? number | X<U> : never) : never): T extends `ivec${string}` ? Int : Float;
     length(): T extends 'vec2' | 'vec3' | 'vec4' ? Float : never;
     lengthSq(): Float;
     luminance(): Float;
@@ -350,6 +400,7 @@ 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;
@@ -452,9 +503,9 @@ interface WebGPUState {
  * for webgl
  */
 interface WebGLState {
-    context: WebGLRenderingContext;
+    context: WebGL2RenderingContext;
     program: WebGLProgram;
-    storages: any;
+    uniforms: Nested<WebGLUniformLocation | null>;
 }
 
 declare const isGL: (a: unknown) => a is EventState<GL>;
@@ -476,6 +527,7 @@ declare const createGL: (props?: Partial<GL>) => EventState<{
     count: number;
     instanceCount: number;
     particleCount: number | [number, number] | [number, number, number];
+    precision: "lowp" | "mediump" | "highp";
     loading: number;
     el: HTMLCanvasElement;
     vs?: string | Vec4;

package/package.json

@@ -1,6 +1,6 @@
 {
         "name": "glre",
-        "version": "0.43.0",
+        "version": "0.44.0",
         "author": "tseijp",
         "license": "MIT",
         "private": false,

package/src/addons/generative/cnoise.ts

@@ -1,4 +1,4 @@
-import { Fn, Vec2, Vec3, Vec4, Float, vec2, vec3, vec4, mix, step } from '../../node'
+import { Fn, Vec2, Vec3, Vec4, Float, vec2, vec3, vec4 } from '../../node'
 import { mod289Vec3, mod289Vec4 } from '../math/mod289'
 import { permuteVec4 } from '../math/permute'
 import { taylorInvSqrt } from '../math/taylorInvSqrt'
@@ -181,30 +181,22 @@ export const cnoiseVec4 = Fn(([P]: [Vec4]): Float => {
         const g1011 = vec4(gx11.y, gy11.y, gz11.y, gw11.y).toVar('g1011')
         const g0111 = vec4(gx11.z, gy11.z, gz11.z, gw11.z).toVar('g0111')
         const g1111 = vec4(gx11.w, gy11.w, gz11.w, gw11.w).toVar('g1111')
-        const norm00 = taylorInvSqrt(
-                vec4(g0000.dot(g0000), g0100.dot(g0100), g1000.dot(g1000), g1100.dot(g1100))
-        ).toVar('norm00')
+        const norm00 = taylorInvSqrt(vec4(g0000.dot(g0000), g0100.dot(g0100), g1000.dot(g1000), g1100.dot(g1100))).toVar('norm00')
         g0000.mulAssign(norm00.x)
         g0100.mulAssign(norm00.y)
         g1000.mulAssign(norm00.z)
         g1100.mulAssign(norm00.w)
-        const norm01 = taylorInvSqrt(
-                vec4(g0001.dot(g0001), g0101.dot(g0101), g1001.dot(g1001), g1101.dot(g1101))
-        ).toVar('norm01')
+        const norm01 = taylorInvSqrt(vec4(g0001.dot(g0001), g0101.dot(g0101), g1001.dot(g1001), g1101.dot(g1101))).toVar('norm01')
         g0001.mulAssign(norm01.x)
         g0101.mulAssign(norm01.y)
         g1001.mulAssign(norm01.z)
         g1101.mulAssign(norm01.w)
-        const norm10 = taylorInvSqrt(
-                vec4(g0010.dot(g0010), g0110.dot(g0110), g1010.dot(g1010), g1110.dot(g1110))
-        ).toVar('norm10')
+        const norm10 = taylorInvSqrt(vec4(g0010.dot(g0010), g0110.dot(g0110), g1010.dot(g1010), g1110.dot(g1110))).toVar('norm10')
         g0010.mulAssign(norm10.x)
         g0110.mulAssign(norm10.y)
         g1010.mulAssign(norm10.z)
         g1110.mulAssign(norm10.w)
-        const norm11 = taylorInvSqrt(
-                vec4(g0011.dot(g0011), g0111.dot(g0111), g1011.dot(g1011), g1111.dot(g1111))
-        ).toVar('norm11')
+        const norm11 = taylorInvSqrt(vec4(g0011.dot(g0011), g0111.dot(g0111), g1011.dot(g1011), g1111.dot(g1111))).toVar('norm11')
         g0011.mulAssign(norm11.x)
         g0111.mulAssign(norm11.y)
         g1011.mulAssign(norm11.z)

package/src/addons/generative/gerstnerWave.ts

@@ -1,4 +1,4 @@
-import { Fn, Vec2, Float, vec3, dot, sqrt, float } from '../../node'
+import { Fn, Vec2, Float, vec3, float } from '../../node'
 import { PI } from '../math/const'
 
 export const gerstnerWave = Fn(([_uv, _dir, _steepness, _wavelength, _time]: [Vec2, Vec2, Float, Float, Float]) => {

package/src/addons/generative/snoise.ts

@@ -78,7 +78,6 @@ export const snoiseVec3 = Fn(([v]: [Vec3]): Float => {
         const p2 = vec3(a1.xy, h.z).toVar('p2')
         const p3 = vec3(a1.zw, h.w).toVar('p3')
         const norm = taylorInvSqrt(vec4(p0.dot(p0), p1.dot(p1), p2.dot(p2), p3.dot(p3))).toVar('norm')
-        p0.mulAssign(norm.x)
         p1.mulAssign(norm.y)
         p2.mulAssign(norm.z)
         p3.mulAssign(norm.w)

package/src/addons/math/mod2.ts

@@ -2,7 +2,7 @@ import { Fn, Vec2, X, vec4 } from '../../node'
 
 // 2D modulo function that returns both cell coordinates and wrapped position
 // Returns vec4(cellX, cellY, wrappedX, wrappedY)
-export const mod2 = Fn(([p, s]: [Vec2, X]): X => {
+export const mod2 = Fn(([p, s]) => {
         const halfS = s.div(2).toVar()
         const pShifted = p.add(halfS).toVar()
         const c = pShifted.div(s).floor().toVar()

package/src/addons/math/taylorInvSqrt.ts

@@ -1,6 +1,6 @@
-import { Fn, X } from '../../node'
+import { Fn, int } from '../../node'
 
-export const taylorInvSqrt = Fn(([r]: [X]): X => {
+export const taylorInvSqrt = Fn(([r]) => {
         return r.mul(-0.85373472095314).add(1.79284291400159)
 }).setLayout({
         name: 'taylorInvSqrt',

package/src/index.ts

@@ -39,6 +39,7 @@ export const createGL = (props?: Partial<GL>) => {
                 count: 6,
                 instanceCount: 1,
                 particleCount: 1024,
+                precision: 'highp',
                 webgl: {},
                 webgpu: {},
                 loading: 0,

package/src/node/build.ts

@@ -1,12 +1,6 @@
 import { code } from './utils'
 import type { NodeContext, X } from './types'
 
-const GLSL_FRAGMENT_HEAD = `
-#version 300 es
-precision mediump float;
-out vec4 fragColor;
-`.trim()
-
 const topological = (headers: Map<string, string>, dependencies: Map<string, Set<string>>) => {
         const sorted: [string, string][] = []
         const visited = new Set<string>()
@@ -42,13 +36,53 @@ const generateStruct = (id: string, map: Map<string, string>) => {
         return `struct ${id} {\n  ${Array.from(map.values()).join(',\n  ')}\n}`
 }
 
+const precisionHead = (result: string[], precision = 'highp') => {
+        result.push(`precision ${precision} float;`)
+        result.push(`precision ${precision} int;`)
+        result.push(`precision ${precision} sampler2D;`)
+        result.push(`precision ${precision} samplerCube;`)
+        result.push(`precision ${precision} sampler3D;`)
+        result.push(`precision ${precision} sampler2DArray;`)
+        result.push(`precision ${precision} sampler2DShadow;`)
+        result.push(`precision ${precision} samplerCubeShadow;`)
+        result.push(`precision ${precision} sampler2DArrayShadow;`)
+        result.push(`precision ${precision} isampler2D;`)
+        result.push(`precision ${precision} isampler3D;`)
+        result.push(`precision ${precision} isamplerCube;`)
+        result.push(`precision ${precision} isampler2DArray;`)
+        result.push(`precision ${precision} usampler2D;`)
+        result.push(`precision ${precision} usampler3D;`)
+        result.push(`precision ${precision} usamplerCube;`)
+        result.push(`precision ${precision} usampler2DArray;`)
+}
+
+// ref: https://github.com/mrdoob/three.js/blob/master/src/renderers/webgl/WebGLCapabilities.js
+const getMaxPrecision = (c?: WebGL2RenderingContext, precision = 'highp') => {
+        if (!c) return 'highp'
+        if (precision === 'highp') {
+                const p0 = c.getShaderPrecisionFormat(c.VERTEX_SHADER, c.HIGH_FLOAT)
+                const p1 = c.getShaderPrecisionFormat(c.FRAGMENT_SHADER, c.HIGH_FLOAT)
+                if (p0 && p0.precision > 0 && p1 && p1.precision > 0) return 'highp'
+                precision = 'mediump'
+        }
+        if (precision === 'mediump') {
+                const p0 = c.getShaderPrecisionFormat(c.VERTEX_SHADER, c.MEDIUM_FLOAT)
+                const p1 = c.getShaderPrecisionFormat(c.FRAGMENT_SHADER, c.MEDIUM_FLOAT)
+                if (p0 && p0.precision > 0 && p1 && p1.precision > 0) return 'mediump'
+                precision = 'lowp'
+        }
+        return 'lowp'
+}
+
 export const fragment = (x: X, c: NodeContext = {}) => {
         c.code?.headers?.clear()
         c.label = 'frag' // for varying inputs or outputs
         const [head, lines, ret] = build(x, c)
         const result = []
         if (c.isWebGL) {
-                result.push(GLSL_FRAGMENT_HEAD)
+                result.push('#version 300 es')
+                precisionHead(result, getMaxPrecision(c.gl?.webgl?.context, c.gl?.precision))
+                result.push('out vec4 fragColor;')
                 for (const code of c.code?.fragInputs?.values() || []) result.push(`in ${code}`)
                 result.push(head)
                 result.push('void main() {')
@@ -106,7 +140,7 @@ export const compute = (x: X, c: NodeContext = {}) => {
         const result = []
         if (c.isWebGL) {
                 result.push('#version 300 es')
-                result.push('precision mediump float;')
+                precisionHead(result, 'highp')
                 result.push(head)
                 result.push('void main() {')
                 result.push(`  ${lines}`)

package/src/node/types.ts

@@ -100,14 +100,6 @@ export interface NodeContext {
 /**
  * infer
  */
-// Optimized string length using direct pattern matching
-// prettier-ignore
-type _StringLength<A extends string> =
-        A extends `${infer _}${infer A}` ? A extends '' ? 1 :
-        A extends `${infer _}${infer B}` ? B extends '' ? 2 :
-        B extends `${infer _}${infer C}` ? C extends '' ? 3 :
-        4 : never : never : never
-
 // Unified logic with infer.ts inferOperator function
 // prettier-ignore
 type InferOperator<L extends C, R extends C> =
@@ -132,28 +124,59 @@ type InferArrayElement<T extends C> =
         T extends 'mat2' ? 'vec2' :
         'float'
 
+type _OperatorTypeRulesMap = typeof OPERATOR_TYPE_RULES
 type ExtractPairs<T> = T extends readonly [infer L, infer R, string] ? [L, R] | [R, L] : never
-type OperatorTypeRules = ExtractPairs<(typeof OPERATOR_TYPE_RULES)[number]>
+type OperatorTypeRules = ExtractPairs<_OperatorTypeRulesMap[number]>
 type IsInRules<L extends C, R extends C> = [L, R] extends OperatorTypeRules ? 1 : 0
 type ValidateOperator<L extends C, R extends C> = L extends R ? 1 : IsInRules<L, R>
 
+/**
+ * swizzle
+ */
+// Optimized string length using direct pattern matching
 // prettier-ignore
-type InferSwizzleType<S extends string> =
-        _StringLength<S> extends 4 ? 'vec4' :
-        _StringLength<S> extends 3 ? 'vec3' :
-        _StringLength<S> extends 2 ? 'vec2' :
-        'float'
+type _SwizzleLength<A extends string> =
+        A extends `${infer _}${infer A}` ? A extends '' ? 1 :
+        A extends `${infer _}${infer B}` ? B extends '' ? 2 :
+        B extends `${infer _}${infer C}` ? C extends '' ? 3 :
+        4 : never : never : never
+
+type _SwizzleBaseMap = {
+        float: 'float'
+        vec2: 'float'
+        vec3: 'float'
+        vec4: 'float'
+        int: 'int'
+        ivec2: 'int'
+        ivec3: 'int'
+        ivec4: 'int'
+        uint: 'uint'
+        uvec2: 'uint'
+        uvec3: 'uint'
+        uvec4: 'uint'
+        bool: 'bool'
+        bvec2: 'bool'
+        bvec3: 'bool'
+        bvec4: 'bool'
+}
+
+type _SwizzleResultMap = {
+        float: { 1: 'float'; 2: 'vec2'; 3: 'vec3'; 4: 'vec4' }
+        int: { 1: 'int'; 2: 'ivec2'; 3: 'ivec3'; 4: 'ivec4' }
+        uint: { 1: 'uint'; 2: 'uvec2'; 3: 'uvec3'; 4: 'uvec4' }
+        bool: { 1: 'bool'; 2: 'bvec2'; 3: 'bvec3'; 4: 'bvec4' }
+}
+
+type _SwizzleBase<T extends C> = T extends keyof _SwizzleBaseMap ? _SwizzleBaseMap[T] : never
+type _SwizzleResult<T extends C, L extends 1 | 2 | 3 | 4> = _SwizzleResultMap[_SwizzleBase<T>][L]
+type InferSwizzleType<T extends C, S extends string> = _SwizzleLength<S> extends infer L extends 1 | 2 | 3 | 4 ? _SwizzleResult<_SwizzleBase<T>, L> : never
 
 /**
  * Swizzles
  */
 type _Swizzles<T extends string> = T | `${T}${T}` | `${T}${T}${T}` | `${T}${T}${T}${T}`
 
-export type Swizzles =
-        | _Swizzles<'x' | 'y' | 'z' | 'w'>
-        | _Swizzles<'r' | 'g' | 'b' | 'a'>
-        | _Swizzles<'p' | 'q'>
-        | _Swizzles<'s' | 't'>
+export type Swizzles = _Swizzles<'x' | 'y' | 'z' | 'w'> | _Swizzles<'r' | 'g' | 'b' | 'a'> | _Swizzles<'p' | 'q'> | _Swizzles<'s' | 't'>
 
 export type Void = XImpl<'void'>
 export type Bool = XImpl<'bool'>
@@ -218,7 +241,7 @@ export interface ConstantsToType {
 type XImpl<T extends C> = _X<T> & {
         [K in string as K extends Methods ? never : K]: any
 } & {
-        [K in Swizzles]: X<InferSwizzleType<K>>
+        [K in Swizzles]: X<InferSwizzleType<T, K>>
 }
 
 type C = Constants
@@ -333,16 +356,8 @@ interface _X<T extends C> {
 
         // 2. WGSL-compliant return types with individual function constraints
         determinant(): T extends 'mat2' | 'mat3' | 'mat4' ? Float : never
-        distance<U extends C>(
-                y: T extends 'vec2' | 'vec3' | 'vec4' ? (U extends T ? number | X<U> : never) : never
-        ): Float
-        dot<U extends C>(
-                y: T extends 'vec2' | 'vec3' | 'vec4' | 'ivec2' | 'ivec3' | 'ivec4'
-                        ? U extends T
-                                ? number | X<U>
-                                : never
-                        : never
-        ): T extends `ivec${string}` ? Int : Float
+        distance<U extends C>(y: T extends 'vec2' | 'vec3' | 'vec4' ? (U extends T ? number | X<U> : never) : never): Float
+        dot<U extends C>(y: T extends 'vec2' | 'vec3' | 'vec4' | 'ivec2' | 'ivec3' | 'ivec4' ? (U extends T ? number | X<U> : never) : never): T extends `ivec${string}` ? Int : Float
         length(): T extends 'vec2' | 'vec3' | 'vec4' ? Float : never
         lengthSq(): Float
         luminance(): Float
@@ -405,13 +420,8 @@ interface _X<T extends C> {
         min<U extends C>(y: number | X<U>): X<InferOperator<T, U>>
         mix<U extends C>(y: number | X<U>, a: number | Float | X<U>): X<InferOperator<T, U>>
         pow<U extends C>(y: number | X<U>): X<T>
-        reflect<U extends C>(
-                N: T extends 'vec2' | 'vec3' | 'vec4' ? (U extends T ? number | X<U> : never) : never
-        ): X<T>
-        refract<U extends C>(
-                N: T extends 'vec2' | 'vec3' | 'vec4' ? (U extends T ? number | X<U> : never) : never,
-                eta: number | Float
-        ): T extends 'vec2' | 'vec3' | 'vec4' ? X<T> : never
+        reflect<U extends C>(N: T extends 'vec2' | 'vec3' | 'vec4' ? (U extends T ? number | X<U> : never) : never): X<T>
+        refract<U extends C>(N: T extends 'vec2' | 'vec3' | 'vec4' ? (U extends T ? number | X<U> : never) : never, eta: number | Float): T extends 'vec2' | 'vec3' | 'vec4' ? X<T> : never
 
         // 2. Functions where not first argument determines return type with unified parameter types
         smoothstep<U extends C>(edge0: number | X<U>, edge1: number | X<U>): X<InferOperator<T, U>>

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/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() {