@zephyr3d/editor 0.3.0 → 0.3.1

package/dist/vendor/zephyr3d/scene/dist/utility/blueprint/material/ir.js

@@ -9,26 +9,26 @@ import { FunctionCallNode, FunctionInputNode, FunctionOutputNode } from './func.
 import { hash11, hash21, hash31, hash12, hash22, hash32, hash13, hash23, hash33, valueNoise } from '../../../shaders/noise.js';
 import { VertexBlockNode } from './pbr.js';
 
-/**
- * Abstract base class for intermediate representation expressions
- *
- * @remarks
- * Represents a node in the IR tree that can be compiled to shader code.
- * Uses reference counting to determine if intermediate variables are needed.
- * Each expression can be referenced multiple times in the final shader code.
- *
- * The IR expression tree is built during compilation and then translated
- * to actual shader code via the `create()` method.
- *
- * @public
+/**
+ * Abstract base class for intermediate representation expressions
+ *
+ * @remarks
+ * Represents a node in the IR tree that can be compiled to shader code.
+ * Uses reference counting to determine if intermediate variables are needed.
+ * Each expression can be referenced multiple times in the final shader code.
+ *
+ * The IR expression tree is built during compilation and then translated
+ * to actual shader code via the `create()` method.
+ *
+ * @public
  */ class IRExpression {
     /** Reference count for this expression (number of times it's used) */ _ref;
     /** Cached output expressions for each output slot */ _outputs;
-    /**
-   * Creates a new IR expression
-   *
-   * @remarks
-   * Initializes reference count to 0 and empty outputs array.
+    /**
+   * Creates a new IR expression
+   *
+   * @remarks
+   * Initializes reference count to 0 and empty outputs array.
    */ constructor(){
         this._ref = 0;
         this._outputs = [];
@@ -36,26 +36,26 @@ import { VertexBlockNode } from './pbr.js';
     /** Gets the array of output expressions */ get outputs() {
         return this._outputs;
     }
-    /**
-   * Increments the reference count
-   *
-   * @returns This expression for method chaining
-   *
-   * @remarks
-   * Called when this expression is referenced by another expression.
-   * Reference count is used to determine if a temporary variable is needed.
+    /**
+   * Increments the reference count
+   *
+   * @returns This expression for method chaining
+   *
+   * @remarks
+   * Called when this expression is referenced by another expression.
+   * Reference count is used to determine if a temporary variable is needed.
    */ addRef() {
         this._ref++;
         return this;
     }
-    /**
-   * Generates a unique temporary variable name
-   *
-   * @param scope - The shader scope to check for name conflicts
-   * @returns A unique temporary variable name (e.g., 'tmp0', 'tmp1')
-   *
-   * @remarks
-   * Ensures the generated name doesn't conflict with existing variables in the scope.
+    /**
+   * Generates a unique temporary variable name
+   *
+   * @param scope - The shader scope to check for name conflicts
+   * @returns A unique temporary variable name (e.g., 'tmp0', 'tmp1')
+   *
+   * @remarks
+   * Ensures the generated name doesn't conflict with existing variables in the scope.
    */ getTmpName(scope) {
         let tmp = 0;
         for(;;){
@@ -65,60 +65,60 @@ import { VertexBlockNode } from './pbr.js';
             }
         }
     }
-    /**
-   * Converts this expression to a uniform value if applicable
-   *
-   * @param _node - The graph node associated with this expression
-   * @returns The uniform value descriptor, or null if not a uniform
-   *
-   * @remarks
-   * Only constant expressions can be converted to uniforms.
-   * Returns null by default; overridden by constant expression types.
+    /**
+   * Converts this expression to a uniform value if applicable
+   *
+   * @param _node - The graph node associated with this expression
+   * @returns The uniform value descriptor, or null if not a uniform
+   *
+   * @remarks
+   * Only constant expressions can be converted to uniforms.
+   * Returns null by default; overridden by constant expression types.
    */ asUniformValue(_node) {
         return null;
     }
-    /**
-   * Converts this expression to a uniform texture if applicable
-   *
-   * @param _node - The graph node associated with this expression
-   * @returns The uniform texture descriptor, or null if not a texture uniform
-   *
-   * @remarks
-   * Only texture constant expressions can be converted to texture uniforms.
-   * Returns null by default; overridden by texture constant expression types.
+    /**
+   * Converts this expression to a uniform texture if applicable
+   *
+   * @param _node - The graph node associated with this expression
+   * @returns The uniform texture descriptor, or null if not a texture uniform
+   *
+   * @remarks
+   * Only texture constant expressions can be converted to texture uniforms.
+   * Returns null by default; overridden by texture constant expression types.
    */ asUniformTexture(_node) {
         return null;
     }
-    /**
-   * Reset state for creation
+    /**
+   * Reset state for creation
    */ reset() {}
 }
-/**
- * IR expression for a constant scalar (float) value
- *
- * @public
+/**
+ * IR expression for a constant scalar (float) value
+ *
+ * @public
  */ class IRConstantf extends IRExpression {
     /** The constant float value */ value;
     /** The uniform parameter name, or empty string for literals */ name;
-    /**
-   * Creates a constant float expression
-   *
-   * @param value - The float value
-   * @param paramName - The uniform parameter name, or empty string for literals
+    /**
+   * Creates a constant float expression
+   *
+   * @param value - The float value
+   * @param paramName - The uniform parameter name, or empty string for literals
    */ constructor(value, paramName){
         super();
         this.value = value;
         this.name = paramName;
     }
-    /**
-   * Generates shader code for this constant
-   *
-   * @param pb - The program builder
-   * @returns A uniform reference or literal number
-   *
-   * @remarks
-   * If a parameter name exists, creates a uniform in the global scope.
-   * Otherwise, returns the literal value.
+    /**
+   * Generates shader code for this constant
+   *
+   * @param pb - The program builder
+   * @returns A uniform reference or literal number
+   *
+   * @remarks
+   * If a parameter name exists, creates a uniform in the global scope.
+   * Otherwise, returns the literal value.
    */ create(pb) {
         if (this.name) {
             if (!pb.getGlobalScope()[this.name]) {
@@ -128,11 +128,11 @@ import { VertexBlockNode } from './pbr.js';
         }
         return this.value;
     }
-    /**
-   * Converts to a uniform value descriptor
-   *
-   * @param node - The graph node
-   * @returns Uniform value descriptor if this is a uniform parameter, null otherwise
+    /**
+   * Converts to a uniform value descriptor
+   *
+   * @param node - The graph node
+   * @returns Uniform value descriptor if this is a uniform parameter, null otherwise
    */ asUniformValue() {
         return this.name ? {
             name: this.name,
@@ -143,57 +143,57 @@ import { VertexBlockNode } from './pbr.js';
         } : null;
     }
 }
-/**
- * IR expression for a constant scalar (boolean) value
- *
- * @public
+/**
+ * IR expression for a constant scalar (boolean) value
+ *
+ * @public
  */ class IRConstantb extends IRExpression {
     /** The constant boolean value */ value;
-    /**
-   * Creates a constant boolean expression
-   *
-   * @param value - The boolean value
+    /**
+   * Creates a constant boolean expression
+   *
+   * @param value - The boolean value
    */ constructor(value){
         super();
         this.value = value;
     }
-    /**
-   * Generates shader code for this constant
-   *
-   * @returns The literal boolean value
-   *
+    /**
+   * Generates shader code for this constant
+   *
+   * @returns The literal boolean value
+   *
    */ create() {
         return this.value;
     }
 }
-/**
- * IR expression for a constant vector value
- *
- * @public
+/**
+ * IR expression for a constant vector value
+ *
+ * @public
  */ class IRConstantfv extends IRExpression {
     /** The constant vector value as an array of floats */ value;
     /** The uniform parameter name, or empty string for literals */ name;
     /** vector type */ type;
-    /**
-   * Creates a constant vector expression
-   *
-   * @param value - The vector value as an array (length 2-4)
-   * @param paramName - The uniform parameter name, or empty string for literals
+    /**
+   * Creates a constant vector expression
+   *
+   * @param value - The vector value as an array (length 2-4)
+   * @param paramName - The uniform parameter name, or empty string for literals
    */ constructor(value, paramName, type){
         super();
         this.value = value;
         this.name = paramName;
         this.type = type;
     }
-    /**
-   * Generates shader code for this constant vector
-   *
-   * @param pb - The program builder
-   * @returns A uniform reference or vector constructor expression
-   *
-   * @remarks
-   * If a parameter name exists, creates a uniform in the global scope.
-   * The vector size is determined by the array length (vec2/vec3/vec4).
+    /**
+   * Generates shader code for this constant vector
+   *
+   * @param pb - The program builder
+   * @returns A uniform reference or vector constructor expression
+   *
+   * @remarks
+   * If a parameter name exists, creates a uniform in the global scope.
+   * The vector size is determined by the array length (vec2/vec3/vec4).
    */ create(pb) {
         if (this.name) {
             if (!pb.getGlobalScope()[this.name]) {
@@ -205,11 +205,11 @@ import { VertexBlockNode } from './pbr.js';
         return(// @ts-ignore
         Array.isArray(this.value) ? pb[`vec${this.value.length}`](...this.value) : this.value);
     }
-    /**
-   * Converts to a uniform value descriptor
-   *
-   * @param node - The graph node
-   * @returns Uniform value descriptor if this is a uniform parameter, null otherwise
+    /**
+   * Converts to a uniform value descriptor
+   *
+   * @param node - The graph node
+   * @returns Uniform value descriptor if this is a uniform parameter, null otherwise
    */ asUniformValue() {
         return this.name ? {
             name: this.name,
@@ -218,97 +218,97 @@ import { VertexBlockNode } from './pbr.js';
         } : null;
     }
 }
-/**
- * IR expression for a constant boolean vector value
- *
- * @public
+/**
+ * IR expression for a constant boolean vector value
+ *
+ * @public
  */ class IRConstantbv extends IRExpression {
     /** The constant vector value as an array of booleans */ value;
-    /**
-   * Creates a constant boolean vector expression
-   *
-   * @param value - The vector value as an array (length 2-4)
+    /**
+   * Creates a constant boolean vector expression
+   *
+   * @param value - The vector value as an array (length 2-4)
    */ constructor(value){
         super();
         this.value = value;
     }
-    /**
-   * Generates shader code for this constant vector
-   *
-   * @param pb - The program builder
-   *
-   * @returns A boolean vector constructor expression
+    /**
+   * Generates shader code for this constant vector
+   *
+   * @param pb - The program builder
+   *
+   * @returns A boolean vector constructor expression
    */ create(pb) {
         // @ts-ignore
         return pb[`bvec${this.value.length}`](...this.value);
     }
 }
-/**
- * IR expression for shader input variables
- *
- * @remarks
- * Represents variables that are passed into the shader from the vertex stage
- * or defined in the current scope. Examples include vertex attributes,
- * varyings, and built-in variables.
- *
- * @example
- * ```typescript
- * // Reference to vertex color
- * const vertexColor = new IRInput('zVertexColor');
- *
- * // Reference via function
- * const worldPos = new IRInput((scope) => scope.zWorldPos);
- * ```
- *
- * @public
+/**
+ * IR expression for shader input variables
+ *
+ * @remarks
+ * Represents variables that are passed into the shader from the vertex stage
+ * or defined in the current scope. Examples include vertex attributes,
+ * varyings, and built-in variables.
+ *
+ * @example
+ * ```typescript
+ * // Reference to vertex color
+ * const vertexColor = new IRInput('zVertexColor');
+ *
+ * // Reference via function
+ * const worldPos = new IRInput((scope) => scope.zWorldPos);
+ * ```
+ *
+ * @public
  */ class IRInput extends IRExpression {
     /** The variable name or a function that retrieves the variable from scope */ func;
-    /**
-   * Creates an input variable expression
-   *
-   * @param func - Variable name string or function to retrieve the variable
+    /**
+   * Creates an input variable expression
+   *
+   * @param func - Variable name string or function to retrieve the variable
    */ constructor(func){
         super();
         this.func = func;
     }
-    /**
-   * Generates shader code for this input variable
-   *
-   * @param pb - The program builder
-   * @returns The shader expression referencing the input variable
+    /**
+   * Generates shader code for this input variable
+   *
+   * @param pb - The program builder
+   * @returns The shader expression referencing the input variable
    */ create(pb) {
         return typeof this.func === 'string' ? pb.getCurrentScope()[this.func] : this.func(pb.getCurrentScope());
     }
 }
-/**
- * IR expression for function calls and operations
- *
- * @remarks
- * Represents built-in shader functions (add, mul, sin, etc.) or vector constructors.
- * Uses reference counting to determine if result should be stored in a temporary variable.
- *
- * @example
- * ```typescript
- * // Addition: a + b
- * const add = new IRFunc([exprA, exprB], 'add');
- *
- * // Vector constructor: vec3(x, y, z)
- * const vec = new IRFunc([x, y, z], 'vec3');
- * ```
- *
- * @public
+/**
+ * IR expression for function calls and operations
+ *
+ * @remarks
+ * Represents built-in shader functions (add, mul, sin, etc.) or vector constructors.
+ * Uses reference counting to determine if result should be stored in a temporary variable.
+ *
+ * @example
+ * ```typescript
+ * // Addition: a + b
+ * const add = new IRFunc([exprA, exprB], 'add');
+ *
+ * // Vector constructor: vec3(x, y, z)
+ * const vec = new IRFunc([x, y, z], 'vec3');
+ * ```
+ *
+ * @public
  */ class IRFunc extends IRExpression {
     /** Array of parameters (can be expressions or literal numbers) */ params;
     /** The function name (e.g., 'add', 'mul', 'sin', 'vec3') */ func;
     /** Cached temporary variable name if expression is referenced multiple times */ tmpName;
-    /**
-   * Creates a function call expression
-   *
-   * @param params - Array of parameters for the function
-   * @param func - The function name or function implementation
-   *
-   * @remarks
-   * Increments reference count for all expression parameters.
+    /**
+   * Creates a function call expression
+   *
+   * @param params - Array of parameters for the function
+   * @param func - The function name or function implementation
+   *
+   * @remarks
+   * Increments reference count for all expression parameters.
    */ constructor(params, func){
         super();
         this.params = params.map((param)=>param instanceof IRExpression ? param.addRef() : param);
@@ -318,15 +318,15 @@ import { VertexBlockNode } from './pbr.js';
     /** Reset for next creation */ reset() {
         this.tmpName = '';
     }
-    /**
-   * Generates shader code for this function call
-   *
-   * @param pb - The program builder
-   * @returns The shader expression for the function result
-   *
-   * @remarks
-   * If referenced multiple times (_ref > 1), stores result in a temporary variable.
-   * Otherwise, generates the function call inline.
+    /**
+   * Generates shader code for this function call
+   *
+   * @param pb - The program builder
+   * @returns The shader expression for the function result
+   *
+   * @remarks
+   * If referenced multiple times (_ref > 1), stores result in a temporary variable.
+   * Otherwise, generates the function call inline.
    */ create(pb) {
         if (this.tmpName) {
             const exp = pb.getCurrentScope()[this.tmpName];
@@ -348,27 +348,27 @@ import { VertexBlockNode } from './pbr.js';
         }
     }
 }
-/**
- * IR expression for function output values
- *
- * @remarks
- * Represents the output of a material function (subgraph).
- * Handles caching of output values when referenced multiple times.
- *
- * @example
- * ```typescript
- * // Function returns a processed color value
- * const output = new IRFunctionOutput(colorExpression);
- * ```
- *
- * @public
+/**
+ * IR expression for function output values
+ *
+ * @remarks
+ * Represents the output of a material function (subgraph).
+ * Handles caching of output values when referenced multiple times.
+ *
+ * @example
+ * ```typescript
+ * // Function returns a processed color value
+ * const output = new IRFunctionOutput(colorExpression);
+ * ```
+ *
+ * @public
  */ class IRFunctionOutput extends IRExpression {
     /** Cached temporary variable name for the output */ tmpName;
     /** The input expression to output */ input;
-    /**
-   * Creates a function output expression
-   *
-   * @param input - The expression or value to output
+    /**
+   * Creates a function output expression
+   *
+   * @param input - The expression or value to output
    */ constructor(input){
         super();
         this.input = input;
@@ -377,14 +377,14 @@ import { VertexBlockNode } from './pbr.js';
     /** Reset for next creation */ reset() {
         this.tmpName = '';
     }
-    /**
-   * Generates shader code for this function output
-   *
-   * @param pb - The program builder
-   * @returns The shader expression or value
-   *
-   * @remarks
-   * If referenced multiple times, stores result in a temporary variable.
+    /**
+   * Generates shader code for this function output
+   *
+   * @param pb - The program builder
+   * @returns The shader expression or value
+   *
+   * @remarks
+   * If referenced multiple times, stores result in a temporary variable.
    */ create(pb) {
         if (this.tmpName) {
             return pb.getCurrentScope()[this.tmpName];
@@ -399,30 +399,30 @@ import { VertexBlockNode } from './pbr.js';
         }
     }
 }
-/**
- * IR expression for calling user-defined material functions
- *
- * @remarks
- * Represents a call to a material function (subgraph) with parameters.
- * Generates both the function definition and the call site.
- * Uses a struct return type to return multiple outputs from the function.
- *
- * @example
- * ```typescript
- * // Call to a custom "calculateLighting" function
- * const call = new IRCallFunc(functionNode, [normalExpr, lightDirExpr]);
- * ```
- *
- * @public
+/**
+ * IR expression for calling user-defined material functions
+ *
+ * @remarks
+ * Represents a call to a material function (subgraph) with parameters.
+ * Generates both the function definition and the call site.
+ * Uses a struct return type to return multiple outputs from the function.
+ *
+ * @example
+ * ```typescript
+ * // Call to a custom "calculateLighting" function
+ * const call = new IRCallFunc(functionNode, [normalExpr, lightDirExpr]);
+ * ```
+ *
+ * @public
  */ class IRCallFunc extends IRExpression {
     /** The function call node from the graph */ node;
     /** Array of argument expressions */ args;
     /** Cached temporary variable name if result is referenced multiple times */ tmpName;
-    /**
-   * Creates a function call expression
-   *
-   * @param node - The function call node
-   * @param args - Array of argument expressions
+    /**
+   * Creates a function call expression
+   *
+   * @param node - The function call node
+   * @param args - Array of argument expressions
    */ constructor(node, args){
         super();
         this.node = node;
@@ -432,16 +432,16 @@ import { VertexBlockNode } from './pbr.js';
     /** Reset for next creation */ reset() {
         this.tmpName = '';
     }
-    /**
-   * Generates shader code for the function definition and call
-   *
-   * @param pb - The program builder
-   * @returns The shader expression for the function result
-   *
-   * @remarks
-   * First generates the function definition (if not already defined),
-   * then generates the function call with the provided arguments.
-   * The function returns a struct containing all output values.
+    /**
+   * Generates shader code for the function definition and call
+   *
+   * @param pb - The program builder
+   * @returns The shader expression for the function result
+   *
+   * @remarks
+   * First generates the function definition (if not already defined),
+   * then generates the function call with the provided arguments.
+   * The function returns a struct containing all output values.
    */ create(pb) {
         if (this.tmpName) {
             return pb.getCurrentScope()[this.tmpName];
@@ -608,82 +608,82 @@ class IRComparison extends IRExpression {
         }
     }
 }
-/**
- * IR expression for vector component swizzling
- *
- * @remarks
- * Extracts specific components from a vector using swizzle notation.
- * For scalar sources, constructs a vector with replicated values.
- *
- * @example
- * ```typescript
- * // Extract xyz from vec4
- * const xyz = new IRSwizzle(vec4Expr, 'xyz');
- *
- * // Extract single component
- * const x = new IRSwizzle(vec3Expr, 'x');
- *
- * // Swizzle and reorder
- * const bgr = new IRSwizzle(rgbExpr, 'bgr');
- * ```
- *
- * @public
+/**
+ * IR expression for vector component swizzling
+ *
+ * @remarks
+ * Extracts specific components from a vector using swizzle notation.
+ * For scalar sources, constructs a vector with replicated values.
+ *
+ * @example
+ * ```typescript
+ * // Extract xyz from vec4
+ * const xyz = new IRSwizzle(vec4Expr, 'xyz');
+ *
+ * // Extract single component
+ * const x = new IRSwizzle(vec3Expr, 'x');
+ *
+ * // Swizzle and reorder
+ * const bgr = new IRSwizzle(rgbExpr, 'bgr');
+ * ```
+ *
+ * @public
  */ class IRSwizzle extends IRExpression {
     /** The source expression to swizzle */ src;
     /** The swizzle pattern (e.g., 'xyz', 'rgb', 'x', 'yzw') */ hash;
-    /**
-   * Creates a swizzle expression
-   *
-   * @param src - The source vector expression
-   * @param hash - The swizzle pattern using xyzw or rgba notation
+    /**
+   * Creates a swizzle expression
+   *
+   * @param src - The source vector expression
+   * @param hash - The swizzle pattern using xyzw or rgba notation
    */ constructor(src, hash){
         super();
         this.src = src.addRef();
         this.hash = hash;
     }
-    /**
-   * Generates shader code for the swizzle operation
-   *
-   * @param pb - The program builder
-   * @returns The swizzled shader expression
-   *
-   * @remarks
-   * If source is a scalar number, creates a vector with that value repeated.
-   * Otherwise, applies the swizzle notation to the source expression.
+    /**
+   * Generates shader code for the swizzle operation
+   *
+   * @param pb - The program builder
+   * @returns The swizzled shader expression
+   *
+   * @remarks
+   * If source is a scalar number, creates a vector with that value repeated.
+   * Otherwise, applies the swizzle notation to the source expression.
    */ create(pb) {
         const src = this.src.create(pb);
         // @ts-ignore
         return typeof src === 'number' ? pb[`vec${this.hash.length}`](src) : src[this.hash];
     }
 }
-/**
- * IR expression for type casting with padding
- *
- * @remarks
- * Converts a value to a different vector type by padding with zeros.
- * Used when a smaller vector needs to be converted to a larger one.
- *
- * @example
- * ```typescript
- * // Cast float to vec3: vec3(value, 0, 0)
- * const vec3 = new IRCast(floatExpr, 'vec3', 2);
- *
- * // Cast vec2 to vec4: vec4(value.xy, 0, 0)
- * const vec4 = new IRCast(vec2Expr, 'vec4', 2);
- * ```
- *
- * @public
+/**
+ * IR expression for type casting with padding
+ *
+ * @remarks
+ * Converts a value to a different vector type by padding with zeros.
+ * Used when a smaller vector needs to be converted to a larger one.
+ *
+ * @example
+ * ```typescript
+ * // Cast float to vec3: vec3(value, 0, 0)
+ * const vec3 = new IRCast(floatExpr, 'vec3', 2);
+ *
+ * // Cast vec2 to vec4: vec4(value.xy, 0, 0)
+ * const vec4 = new IRCast(vec2Expr, 'vec4', 2);
+ * ```
+ *
+ * @public
  */ class IRCast extends IRExpression {
     /** The source expression to cast */ src;
     /** The values to be filled */ fill;
     /** The target type name (e.g., 'vec2', 'vec3', 'vec4') */ type;
     /** Number of zero components to append */ cast;
-    /**
-   * Creates a type cast expression
-   *
-   * @param src - The source expression
-   * @param type - The target type name
-   * @param cast - Number of zero components to append
+    /**
+   * Creates a type cast expression
+   *
+   * @param src - The source expression
+   * @param type - The target type name
+   * @param cast - Number of zero components to append
    */ constructor(src, type, cast, fill){
         super();
         this.src = src.addRef();
@@ -691,15 +691,15 @@ class IRComparison extends IRExpression {
         this.fill = fill?.slice() ?? null;
         this.type = type;
     }
-    /**
-   * Generates shader code for the type cast
-   *
-   * @param pb - The program builder
-   * @returns The casted shader expression
-   *
-   * @remarks
-   * Creates a vector constructor with the source value followed by zeros.
-   * Example: vec4(src, 0, 0) for casting vec2 to vec4.
+    /**
+   * Generates shader code for the type cast
+   *
+   * @param pb - The program builder
+   * @returns The casted shader expression
+   *
+   * @remarks
+   * Creates a vector constructor with the source value followed by zeros.
+   * Example: vec4(src, 0, 0) for casting vec2 to vec4.
    */ create(pb) {
         // @ts-ignore
         return pb[this.type](this.src.create(pb), ...this.fill ?? Array.from({
@@ -707,35 +707,35 @@ class IRComparison extends IRExpression {
         }).fill(0));
     }
 }
-/**
- * IR expression for texture sampling
- *
- * @remarks
- * Represents a texture lookup operation with optional normal map decoding.
- * Handles both color and normal map sampling with appropriate transformations.
- * Uses reference counting to cache the sampled result if used multiple times.
- *
- * @example
- * ```typescript
- * // Sample color texture
- * const color = new IRSampleTexture(texExpr, uvExpr, 'Color');
- *
- * // Sample normal map (automatically decodes from [0,1] to [-1,1])
- * const normal = new IRSampleTexture(texExpr, uvExpr, 'Normal');
- * ```
- *
- * @public
+/**
+ * IR expression for texture sampling
+ *
+ * @remarks
+ * Represents a texture lookup operation with optional normal map decoding.
+ * Handles both color and normal map sampling with appropriate transformations.
+ * Uses reference counting to cache the sampled result if used multiple times.
+ *
+ * @example
+ * ```typescript
+ * // Sample color texture
+ * const color = new IRSampleTexture(texExpr, uvExpr, 'Color');
+ *
+ * // Sample normal map (automatically decodes from [0,1] to [-1,1])
+ * const normal = new IRSampleTexture(texExpr, uvExpr, 'Normal');
+ * ```
+ *
+ * @public
  */ class IRSampleTexture extends IRExpression {
     /** The texture expression */ tex;
     /** The texture coordinate expression */ coord;
     /** The sampler type determining how to interpret the sampled value */ samplerType;
     /** Cached temporary variable name if result is referenced multiple times */ tmpName;
-    /**
-   * Creates a texture sample expression
-   *
-   * @param tex - The texture to sample from
-   * @param coord - The texture coordinates
-   * @param samplerType - How to interpret the sampled value ('Color' or 'Normal')
+    /**
+   * Creates a texture sample expression
+   *
+   * @param tex - The texture to sample from
+   * @param coord - The texture coordinates
+   * @param samplerType - How to interpret the sampled value ('Color' or 'Normal')
    */ constructor(tex, coord, samplerType){
         super();
         this.tex = tex.addRef();
@@ -746,18 +746,18 @@ class IRComparison extends IRExpression {
     /** Reset for next creation */ reset() {
         this.tmpName = '';
     }
-    /**
-   * Generates shader code for the texture sample operation
-   *
-   * @param pb - The program builder
-   * @returns The sampled color value
-   *
-   * @remarks
-   * For normal maps, applies the transformation: normal * 2 - 1 to convert
-   * from [0,1] texture space to [-1,1] tangent space.
-   * Caches result in a temporary variable if referenced multiple times.
-   *
-   * @throws Error if texture coordinate is not a valid expression or array
+    /**
+   * Generates shader code for the texture sample operation
+   *
+   * @param pb - The program builder
+   * @returns The sampled color value
+   *
+   * @remarks
+   * For normal maps, applies the transformation: normal * 2 - 1 to convert
+   * from [0,1] texture space to [-1,1] tangent space.
+   * Caches result in a temporary variable if referenced multiple times.
+   *
+   * @throws Error if texture coordinate is not a valid expression or array
    */ create(pb) {
         if (this.tmpName) {
             return pb.getCurrentScope()[this.tmpName];
@@ -792,27 +792,27 @@ class IRComparison extends IRExpression {
         }
     }
 }
-/**
- * IR expression for texture uniform constants
- *
- * @remarks
- * Represents a texture parameter that will be bound as a uniform.
- * Includes sampler configuration for texture filtering and addressing modes.
- *
- * @example
- * ```typescript
- * const tex = new IRConstantTexture(
- *   'u_baseColorMap',
- *   'tex2d',
- *   'repeat',
- *   'repeat',
- *   'linear',
- *   'linear',
- *   'linear'
- * );
- * ```
- *
- * @public
+/**
+ * IR expression for texture uniform constants
+ *
+ * @remarks
+ * Represents a texture parameter that will be bound as a uniform.
+ * Includes sampler configuration for texture filtering and addressing modes.
+ *
+ * @example
+ * ```typescript
+ * const tex = new IRConstantTexture(
+ *   'u_baseColorMap',
+ *   'tex2d',
+ *   'repeat',
+ *   'repeat',
+ *   'linear',
+ *   'linear',
+ *   'linear'
+ * );
+ * ```
+ *
+ * @public
  */ class IRConstantTexture extends IRExpression {
     /** The uniform texture variable name */ name;
     /** The texture id */ id;
@@ -824,18 +824,18 @@ class IRComparison extends IRExpression {
     /** Magnification filter mode */ filterMag;
     /** Mipmap filter mode */ filterMip;
     /** Whether texture params is used */ useParams;
-    /**
-   * Creates a texture constant expression
-   *
-   * @param name - The uniform variable name
-   * @param id - The texture id
-   * @param type - The texture type
-   * @param sRGB - Whether this texture should be loaded in sRGB color space
-   * @param addressU - Horizontal addressing mode
-   * @param addressV - Vertical addressing mode
-   * @param minFilter - Minification filter
-   * @param magFilter - Magnification filter
-   * @param mipFilter - Mipmap filter
+    /**
+   * Creates a texture constant expression
+   *
+   * @param name - The uniform variable name
+   * @param id - The texture id
+   * @param type - The texture type
+   * @param sRGB - Whether this texture should be loaded in sRGB color space
+   * @param addressU - Horizontal addressing mode
+   * @param addressV - Vertical addressing mode
+   * @param minFilter - Minification filter
+   * @param magFilter - Magnification filter
+   * @param mipFilter - Mipmap filter
    */ constructor(name, id, type, sRGB, addressU, addressV, minFilter, magFilter, mipFilter){
         super();
         this.name = name;
@@ -849,14 +849,14 @@ class IRComparison extends IRExpression {
         this.filterMip = mipFilter;
         this.useParams = false;
     }
-    /**
-   * Generates shader code for the texture uniform
-   *
-   * @param pb - The program builder
-   * @returns The texture uniform reference
-   *
-   * @remarks
-   * Creates the uniform declaration in the global scope if not already present.
+    /**
+   * Generates shader code for the texture uniform
+   *
+   * @param pb - The program builder
+   * @returns The texture uniform reference
+   *
+   * @remarks
+   * Creates the uniform declaration in the global scope if not already present.
    */ create(pb) {
         if (!pb.getGlobalScope()[this.name]) {
             // @ts-ignore
@@ -864,11 +864,11 @@ class IRComparison extends IRExpression {
         }
         return pb.getGlobalScope()[this.name];
     }
-    /**
-   * Converts to a uniform texture descriptor
-   *
-   * @param node - The texture node
-   * @returns Uniform texture descriptor with texture and sampler references
+    /**
+   * Converts to a uniform texture descriptor
+   *
+   * @param node - The texture node
+   * @returns Uniform texture descriptor with texture and sampler references
    */ asUniformTexture() {
         return {
             name: this.name,
@@ -883,24 +883,24 @@ class IRComparison extends IRExpression {
         };
     }
 }
-/**
- * Material Blueprint Intermediate Representation
- *
- * @remarks
- * The IR is a compiled representation of the material node graph that can be
- * efficiently translated to shader code. It performs:
- * - Type checking and validation
- * - Expression optimization (common subexpression elimination via reference counting)
- * - Uniform extraction (constants become shader uniforms)
- * - Dependency analysis (determines required vertex attributes)
- *
- * The compilation process:
- * 1. Traverse the DAG in topological order
- * 2. Build an IR expression tree
- * 3. Track uniforms and behaviors
- * 4. Generate optimized shader code from the IR
- *
- * @public
+/**
+ * Material Blueprint Intermediate Representation
+ *
+ * @remarks
+ * The IR is a compiled representation of the material node graph that can be
+ * efficiently translated to shader code. It performs:
+ * - Type checking and validation
+ * - Expression optimization (common subexpression elimination via reference counting)
+ * - Uniform extraction (constants become shader uniforms)
+ * - Dependency analysis (determines required vertex attributes)
+ *
+ * The compilation process:
+ * 1. Traverse the DAG in topological order
+ * 2. Build an IR expression tree
+ * 3. Track uniforms and behaviors
+ * 4. Generate optimized shader code from the IR
+ *
+ * @public
  */ class MaterialBlueprintIR {
     /** The directed acyclic graph of material nodes */ _dag;
     /** Unique hash identifying this material configuration */ _hash;
@@ -912,16 +912,16 @@ class IRComparison extends IRExpression {
     /** Fallback texture uniforms generated for TextureSample nodes without texture input */ _textureSampleFallbackMap;
     /** Flags indicating which shader features are used */ _behaviors;
     /** Array of named output expressions (e.g., baseColor, normal, metallic) */ _outputs;
-    /**
-   * Creates and compiles a material blueprint IR
-   *
-   * @param dag - The material node graph DAG
-   * @param hash - Unique identifier for this material
-   * @param editorState - Editor state snapshot
-   *
-   * @remarks
-   * Automatically compiles the DAG during construction.
-   * Check the `ok` property to verify successful compilation.
+    /**
+   * Creates and compiles a material blueprint IR
+   *
+   * @param dag - The material node graph DAG
+   * @param hash - Unique identifier for this material
+   * @param editorState - Editor state snapshot
+   *
+   * @remarks
+   * Automatically compiles the DAG during construction.
+   * Check the `ok` property to verify successful compilation.
    */ constructor(dag, hash, editorState){
         this._dag = dag ?? {
             nodeMap: {},
@@ -936,10 +936,10 @@ class IRComparison extends IRExpression {
         this._editorState = editorState;
         this.compile();
     }
-    /**
-   * Whether the IR compiled successfully
-   *
-   * @returns True if compilation produced valid outputs
+    /**
+   * Whether the IR compiled successfully
+   *
+   * @returns True if compilation produced valid outputs
    */ get ok() {
         return this._outputs ? this._outputs.length > 0 : false;
     }
@@ -964,17 +964,17 @@ class IRComparison extends IRExpression {
     /** Gets the array of uniform textures to bind at runtime */ get uniformTextures() {
         return this._uniformTextures;
     }
-    /**
-   * Compiles the material node graph to IR
-   *
-   * @returns True if compilation succeeded, false otherwise
-   *
-   * @remarks
-   * Processes all root nodes (typically a single material output node)
-   * and builds IR expressions for all connected inputs.
-   * Collects all required uniforms and sets behavior flags.
-   *
-   * Compilation fails if any required input is missing.
+    /**
+   * Compiles the material node graph to IR
+   *
+   * @returns True if compilation succeeded, false otherwise
+   *
+   * @remarks
+   * Processes all root nodes (typically a single material output node)
+   * and builds IR expressions for all connected inputs.
+   * Collects all required uniforms and sets behavior flags.
+   *
+   * Compilation fails if any required input is missing.
    */ compile() {
         this.reset();
         this._outputs = [];
@@ -1014,24 +1014,24 @@ class IRComparison extends IRExpression {
         }
         return true;
     }
-    /**
-   * Generates shader code from the IR
-   *
-   * @param pb - The program builder to generate code with
-   * @returns Array of named shader expressions, or null if IR is invalid
-   *
-   * @remarks
-   * Translates all IR expressions to actual shader code.
-   * Should be called within a shader function scope.
-   *
-   * @example
-   * ```typescript
-   * pb.fragmentShader(function() {
-   *   const outputs = ir.create(this);
-   *   this.baseColor = outputs.find(o => o.name === 'baseColor').exp;
-   *   this.normal = outputs.find(o => o.name === 'normal').exp;
-   * });
-   * ```
+    /**
+   * Generates shader code from the IR
+   *
+   * @param pb - The program builder to generate code with
+   * @returns Array of named shader expressions, or null if IR is invalid
+   *
+   * @remarks
+   * Translates all IR expressions to actual shader code.
+   * Should be called within a shader function scope.
+   *
+   * @example
+   * ```typescript
+   * pb.fragmentShader(function() {
+   *   const outputs = ir.create(this);
+   *   this.baseColor = outputs.find(o => o.name === 'baseColor').exp;
+   *   this.normal = outputs.find(o => o.name === 'normal').exp;
+   * });
+   * ```
    */ create(pb) {
         if (!this._outputs) {
             return null;
@@ -1048,12 +1048,12 @@ class IRComparison extends IRExpression {
         }
         return outputs;
     }
-    /**
-   * Resets the IR state for recompilation
-   *
-   * @remarks
-   * Clears all compiled data including expressions, uniforms, and behaviors.
-   * Called at the start of compilation.
+    /**
+   * Resets the IR state for recompilation
+   *
+   * @remarks
+   * Clears all compiled data including expressions, uniforms, and behaviors.
+   * Called at the start of compilation.
    */ reset() {
         this._expressions = [];
         this._expressionMap = new Map();
@@ -1066,19 +1066,19 @@ class IRComparison extends IRExpression {
             useVertexUV: false
         };
     }
-    /**
-   * Converts a graph node to an IR expression
-   *
-   * @param node - The graph node to convert
-   * @param output - The output slot ID
-   * @param originType - Optional type override for type casting
-   * @returns The corresponding IR expression
-   *
-   * @remarks
-   * Main dispatch method that routes to specific converters based on node type.
-   * Handles automatic type casting when originType differs from node output type.
-   *
-   * @throws Error if type casting is invalid
+    /**
+   * Converts a graph node to an IR expression
+   *
+   * @param node - The graph node to convert
+   * @param output - The output slot ID
+   * @param originType - Optional type override for type casting
+   * @returns The corresponding IR expression
+   *
+   * @remarks
+   * Main dispatch method that routes to specific converters based on node type.
+   * Handles automatic type casting when originType differs from node output type.
+   *
+   * @throws Error if type casting is invalid
    */ ir(inputNode) {
         const node = inputNode.inputNode;
         const output = inputNode.inputId;
@@ -1206,19 +1206,19 @@ class IRComparison extends IRExpression {
         }
         return expr;
     }
-    /**
-   * Gets or creates an IR expression for a graph node
-   *
-   * @param node - The graph node
-   * @param outputId - The output slot ID
-   * @param ctor - The IR expression constructor
-   * @param args - Constructor arguments
-   * @returns The cached or newly created IR expression
-   *
-   * @remarks
-   * Implements common subexpression elimination by caching expressions per node.
-   * Handles output slot swizzling and type casting.
-   * Collects uniform values and textures.
+    /**
+   * Gets or creates an IR expression for a graph node
+   *
+   * @param node - The graph node
+   * @param outputId - The output slot ID
+   * @param ctor - The IR expression constructor
+   * @param args - Constructor arguments
+   * @returns The cached or newly created IR expression
+   *
+   * @remarks
+   * Implements common subexpression elimination by caching expressions per node.
+   * Handles output slot swizzling and type casting.
+   * Collects uniform values and textures.
    */ getOrCreateIRExpression(node, outputId, ctor, ...args) {
         let ir;
         if (!this._expressionMap.has(node)) {
@@ -1473,11 +1473,11 @@ class IRComparison extends IRExpression {
                 this.$l.objUp = pb.normalize(pb.div(pb.mul(this.cameraUp, this.rotation), this.objScale));
                 this.$l.objRight = pb.normalize(pb.div(pb.mul(this.cameraRight, this.rotation), this.objScale));
                 // make ortho
-                /*
-        this.objRight = pb.normalize(
-          pb.sub(this.objRight, pb.mul(this.objUp, pb.dot(this.objRight, this.objUp)))
-        );
-        this.objForward = pb.cross(this.objUp, this.objRight);
+                /*
+        this.objRight = pb.normalize(
+          pb.sub(this.objRight, pb.mul(this.objUp, pb.dot(this.objRight, this.objUp)))
+        );
+        this.objForward = pb.cross(this.objUp, this.objRight);
         */ // make rotation matrix
                 this.$l.billboardMatrix = pb.mat3(this.objRight.x, this.objUp.x, this.objForward.x, this.objRight.y, this.objUp.y, this.objForward.y, this.objRight.z, this.objUp.z, this.objForward.z);
                 this.$return(pb.transpose(this.billboardMatrix));