glre 0.43.0 → 0.45.0

package/dist/react.d.ts

@@ -112,7 +112,7 @@ interface NodeContext {
         fragInputs: Map<string, string>;
         vertInputs: Map<string, string>;
         vertOutputs: Map<string, string>;
-        vertVaryings: Map<string, string>;
+        vertVaryings: Map<string, VaryingInfo>;
         computeInputs: Map<string, string>;
         dependencies: Map<string, Set<string>>;
         structStructFields: Map<string, StructFields>;
@@ -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
  */
@@ -158,6 +208,10 @@ type Mat4 = XImpl<'mat4'>;
 type Texture$1 = XImpl<'texture'>;
 type Sampler2D = XImpl<'sampler2D'>;
 type StructBase = XImpl<'struct'>;
+interface VaryingInfo {
+    node: Y;
+    code?: string;
+}
 interface ConstantsToType {
     void: Void;
     bool: Bool;
@@ -190,10 +244,11 @@ 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>;
+type Y<T extends C = C> = number | number[] | string | boolean | undefined | HTMLElement | X<T>;
 type Methods = Functions | Operators | Conversions | Swizzles | '__nodeType' | 'type' | 'props' | 'isProxy' | 'assign' | 'toVar' | 'toString' | 'element' | 'select';
 interface _X<T extends C> {
     readonly __nodeType?: T;
@@ -270,7 +325,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 +405,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 +508,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 +532,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

@@ -112,7 +112,7 @@ interface NodeContext {
         fragInputs: Map<string, string>;
         vertInputs: Map<string, string>;
         vertOutputs: Map<string, string>;
-        vertVaryings: Map<string, string>;
+        vertVaryings: Map<string, VaryingInfo>;
         computeInputs: Map<string, string>;
         dependencies: Map<string, Set<string>>;
         structStructFields: Map<string, StructFields>;
@@ -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
  */
@@ -158,6 +208,10 @@ type Mat4 = XImpl<'mat4'>;
 type Texture$1 = XImpl<'texture'>;
 type Sampler2D = XImpl<'sampler2D'>;
 type StructBase = XImpl<'struct'>;
+interface VaryingInfo {
+    node: Y;
+    code?: string;
+}
 interface ConstantsToType {
     void: Void;
     bool: Bool;
@@ -190,10 +244,11 @@ 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>;
+type Y<T extends C = C> = number | number[] | string | boolean | undefined | HTMLElement | X<T>;
 type Methods = Functions | Operators | Conversions | Swizzles | '__nodeType' | 'type' | 'props' | 'isProxy' | 'assign' | 'toVar' | 'toString' | 'element' | 'select';
 interface _X<T extends C> {
     readonly __nodeType?: T;
@@ -270,7 +325,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 +405,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 +508,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 +532,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.45.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() {')
@@ -70,6 +104,7 @@ export const fragment = (x: X, c: NodeContext = {}) => {
 export const vertex = (x: X, c: NodeContext = {}) => {
         c.code?.headers?.clear()
         c.label = 'vert' // for varying inputs or outputs
+        if (c.code) for (const [id, { node }] of c.code.vertVaryings.entries()) c.code.vertVaryings.set(id, { node, code: code(node, c) }) // ① prebuild varying.code because the scope (e.g. output function definitions) is fixed to vertex.
         const [head, lines, ret] = build(x, c)
         const result = []
         if (c.isWebGL) {
@@ -80,7 +115,7 @@ export const vertex = (x: X, c: NodeContext = {}) => {
                 result.push('void main() {')
                 result.push(`  ${lines}`)
                 result.push(`  gl_Position = ${ret};`)
-                for (const [id, code] of c.code?.vertVaryings?.entries() || []) result.push(`  ${id} = ${code};`)
+                if (c.code) for (const [id, varying] of c.code.vertVaryings.entries()) result.push(`  ${id} = ${varying.code!};`) // ② varying.code is already prebuilt
         } else {
                 if (c.code?.vertInputs?.size) result.push(generateStruct('In', c.code.vertInputs))
                 if (c.code?.vertOutputs?.size) result.push(generateStruct('Out', c.code.vertOutputs))
@@ -90,7 +125,7 @@ export const vertex = (x: X, c: NodeContext = {}) => {
                 result.push('  var out: Out;')
                 result.push(`  ${lines}`)
                 result.push(`  out.position = ${ret};`)
-                for (const [id, code] of c.code?.vertVaryings?.entries() || []) result.push(`  out.${id} = ${code};`)
+                if (c.code) for (const [id, varying] of c.code.vertVaryings.entries()) result.push(`  out.${id} = ${varying.code!};`)
                 result.push('  return out;')
         }
         result.push('}')
@@ -106,7 +141,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

@@ -90,7 +90,7 @@ export interface NodeContext {
                 fragInputs: Map<string, string>
                 vertInputs: Map<string, string>
                 vertOutputs: Map<string, string>
-                vertVaryings: Map<string, string>
+                vertVaryings: Map<string, VaryingInfo>
                 computeInputs: Map<string, string>
                 dependencies: Map<string, Set<string>>
                 structStructFields: Map<string, StructFields>
@@ -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'>
@@ -179,6 +202,12 @@ export type Mat4 = XImpl<'mat4'>
 export type Texture = XImpl<'texture'>
 export type Sampler2D = XImpl<'sampler2D'>
 export type StructBase = XImpl<'struct'>
+
+export interface VaryingInfo {
+        node: Y
+        code?: string
+}
+
 export type Struct<T extends StructFields = any> = Omit<StructBase, keyof T> & {
         [K in keyof T]: T[K] extends X<infer U> ? X<U> : never
 } & {
@@ -218,7 +247,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 +362,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 +426,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>>