@zephyr3d/scene 0.7.0 → 0.7.1

package/dist/utility/blueprint/material/ir.js

@@ -1,8 +1,8 @@
 import { PBShaderExp } from '@zephyr3d/device';
-import { ConstantScalarNode, ConstantVec2Node, ConstantVec3Node, ConstantVec4Node } from '../common/constants.js';
+import { ConstantScalarNode, ConstantVec2Node, ConstantVec3Node, ConstantVec4Node, ConstantBooleanNode, ConstantBVec2Node, ConstantBVec3Node, ConstantBVec4Node } from '../common/constants.js';
 import { ASSERT } from '@zephyr3d/base';
 import { BaseTextureNode, TextureSampleNode } from './texture.js';
-import { MakeVectorNode, SwizzleNode, Hash1Node, Hash2Node, Hash3Node, SimplexNoise2DNode, PerlinNoise2DNode, GenericMathNode, TransformNode } from '../common/math.js';
+import { MakeVectorNode, SwizzleNode, CompComparisonNode, AnyConditionNode, AllConditionNode, SelectionNode, Hash1Node, Hash2Node, Hash3Node, SimplexNoise2DNode, PerlinNoise2DNode, GenericMathNode, TransformNode } from '../common/math.js';
 import { ResolveVertexPositionNode, ResolveVertexNormalNode, ResolveVertexTangentNode, VertexColorNode, VertexUVNode, VertexPositionNode, VertexNormalNode, VertexTangentNode, VertexBinormalNode, ViewMatrixNode, ProjectionMatrixNode, ViewProjMatrixNode, InvProjMatrixNode, InvViewProjMatrixNode, BillboardMatrixNode, CameraPositionNode, CameraNearFarNode, SkyEnvTextureNode, ElapsedTimeNode } from './inputs.js';
 import { ShaderHelper } from '../../../material/shader/helper.js';
 import { FunctionCallNode, FunctionInputNode, FunctionOutputNode } from './func.js';
@@ -96,19 +96,6 @@ import { VertexBlockNode } from './pbr.js';
 /**
  * IR expression for a constant scalar (float) value
  *
- * @remarks
- * Represents either a literal constant or a uniform parameter.
- * If a parameter name is provided, generates a uniform; otherwise, uses a literal.
- *
- * @example
- * ```typescript
- * // Literal constant
- * const literal = new IRConstantf(1.5, '');
- *
- * // Uniform parameter
- * const uniform = new IRConstantf(1.0, 'u_roughness');
- * ```
- *
  * @public
  */ class IRConstantf extends IRExpression {
     /** The constant float value */ value;
@@ -157,20 +144,30 @@ import { VertexBlockNode } from './pbr.js';
     }
 }
 /**
- * IR expression for a constant vector value
- *
- * @remarks
- * Represents vec2, vec3, or vec4 constants.
- * Can be either literals or uniform parameters.
+ * IR expression for a constant scalar (boolean) value
  *
- * @example
- * ```typescript
- * // Literal vec3
- * const color = new IRConstantfv([1.0, 0.0, 0.0], '');
- *
- * // Uniform vec2
- * const param = new IRConstantfv([0.5, 0.5], 'u_offset');
- * ```
+ * @public
+ */ class IRConstantb extends IRExpression {
+    /** The constant boolean value */ 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
+   *
+   */ create() {
+        return this.value;
+    }
+}
+/**
+ * IR expression for a constant vector value
  *
  * @public
  */ class IRConstantfv extends IRExpression {
@@ -200,11 +197,13 @@ import { VertexBlockNode } from './pbr.js';
    */ create(pb) {
         if (this.name) {
             if (!pb.getGlobalScope()[this.name]) {
+                // @ts-ignore
                 pb.getGlobalScope()[this.name] = pb[`vec${this.value.length}`]().uniform(2);
             }
             return pb.getGlobalScope()[this.name];
         }
-        return Array.isArray(this.value) ? pb[`vec${this.value.length}`](...this.value) : this.value;
+        return(// @ts-ignore
+        Array.isArray(this.value) ? pb[`vec${this.value.length}`](...this.value) : this.value);
     }
     /**
    * Converts to a uniform value descriptor
@@ -219,6 +218,31 @@ import { VertexBlockNode } from './pbr.js';
         } : null;
     }
 }
+/**
+ * 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)
+   */ constructor(value){
+        super();
+        this.value = value;
+    }
+    /**
+   * 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
  *
@@ -306,10 +330,11 @@ import { VertexBlockNode } from './pbr.js';
    */ create(pb) {
         if (this.tmpName) {
             const exp = pb.getCurrentScope()[this.tmpName];
-            ASSERT(exp, 'expression not exists');
+            ASSERT(!!exp, 'expression not exists');
             return exp;
         }
         const params = this.params.map((param)=>param instanceof IRExpression ? param.create(pb) : param);
+        // @ts-ignore
         const exp = typeof this.func === 'string' ? pb[this.func](...params) : this.func(pb, ...params);
         if (this._ref === 1) {
             return exp;
@@ -420,10 +445,12 @@ import { VertexBlockNode } from './pbr.js';
         }
         const that = this;
         const ir = this.node.IR;
+        // @ts-ignore
         const params = this.node.args.map((v)=>pb[v.type](v.name));
         pb.func(this.node.name, params, function() {
             const outputs = ir.create(pb);
             const rettype = pb.defineStruct(that.node.outputs.map((output, index)=>{
+                // @ts-ignore
                 return pb[that.node.outs[index].type](output.swizzle);
             }));
             this.$return(rettype(...outputs.map((output)=>{
@@ -441,6 +468,143 @@ import { VertexBlockNode } from './pbr.js';
         }
     }
 }
+class IRSelection extends IRExpression {
+    a;
+    b;
+    cond;
+    tmpName;
+    constructor(a, b, cond){
+        super();
+        this.a = a.addRef();
+        this.b = b.addRef();
+        this.cond = cond.addRef();
+        this.tmpName = '';
+    }
+    reset() {
+        this.tmpName = '';
+    }
+    create(pb) {
+        if (this.tmpName) {
+            return pb.getCurrentScope()[this.tmpName];
+        }
+        const a = this.a.create(pb);
+        const b = this.b.create(pb);
+        const c = this.cond.create(pb);
+        const exp = pb.select(a, b, typeof c === 'number' ? c !== 0 : c);
+        if (this._ref === 1) {
+            return exp;
+        } else {
+            this.tmpName = this.getTmpName(pb.getCurrentScope());
+            pb.getCurrentScope()[this.tmpName] = exp;
+            return pb.getCurrentScope()[this.tmpName];
+        }
+    }
+}
+class IRAny extends IRExpression {
+    src;
+    tmpName;
+    constructor(src){
+        super();
+        this.src = src.addRef();
+        this.tmpName = '';
+    }
+    reset() {
+        this.tmpName = '';
+    }
+    create(pb) {
+        if (this.tmpName) {
+            return pb.getCurrentScope()[this.tmpName];
+        }
+        const src = this.src.create(pb);
+        const exp = pb.any(src);
+        if (this._ref === 1) {
+            return exp;
+        } else {
+            this.tmpName = this.getTmpName(pb.getCurrentScope());
+            pb.getCurrentScope()[this.tmpName] = exp;
+            return pb.getCurrentScope()[this.tmpName];
+        }
+    }
+}
+class IRAll extends IRExpression {
+    src;
+    tmpName;
+    constructor(src){
+        super();
+        this.src = src.addRef();
+        this.tmpName = '';
+    }
+    reset() {
+        this.tmpName = '';
+    }
+    create(pb) {
+        if (this.tmpName) {
+            return pb.getCurrentScope()[this.tmpName];
+        }
+        const src = this.src.create(pb);
+        const exp = pb.all(src);
+        if (this._ref === 1) {
+            return exp;
+        } else {
+            this.tmpName = this.getTmpName(pb.getCurrentScope());
+            pb.getCurrentScope()[this.tmpName] = exp;
+            return pb.getCurrentScope()[this.tmpName];
+        }
+    }
+}
+class IRComparison extends IRExpression {
+    a;
+    b;
+    mode;
+    tmpName;
+    constructor(a, b, mode){
+        super();
+        this.a = a.addRef();
+        this.b = b.addRef();
+        this.mode = mode;
+        this.tmpName = '';
+    }
+    /** Reset for next creation */ reset() {
+        this.tmpName = '';
+    }
+    create(pb) {
+        if (this.tmpName) {
+            return pb.getCurrentScope()[this.tmpName];
+        }
+        const a = this.a.create(pb);
+        const b = this.b.create(pb);
+        let exp;
+        switch(this.mode){
+            case 'eq':
+                exp = pb.compEqual(a, b);
+                break;
+            case 'ne':
+                exp = pb.compNotEqual(a, b);
+                break;
+            case 'lt':
+                exp = pb.lessThan(a, b);
+                break;
+            case 'le':
+                exp = pb.lessThanEqual(a, b);
+                break;
+            case 'gt':
+                exp = pb.greaterThan(a, b);
+                break;
+            case 'ge':
+                exp = pb.greaterThanEqual(a, b);
+                break;
+            default:
+                throw new Error(`Invalid comparison mode: ${this.mode}`);
+        }
+        if (this._ref === 1) {
+            return exp;
+        } else {
+            this.tmpName = this.getTmpName(pb.getCurrentScope());
+            pb.getCurrentScope()[this.tmpName] = exp;
+            return pb.getCurrentScope()[this.tmpName];
+        }
+    }
+}
 /**
  * IR expression for vector component swizzling
  *
@@ -485,6 +649,7 @@ import { VertexBlockNode } from './pbr.js';
    * 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];
     }
 }
@@ -507,6 +672,7 @@ import { VertexBlockNode } from './pbr.js';
  * @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;
     /**
@@ -515,10 +681,11 @@ import { VertexBlockNode } from './pbr.js';
    * @param src - The source expression
    * @param type - The target type name
    * @param cast - Number of zero components to append
-   */ constructor(src, type, cast){
+   */ constructor(src, type, cast, fill){
         super();
         this.src = src.addRef();
         this.cast = cast;
+        this.fill = fill?.slice() ?? null;
         this.type = type;
     }
     /**
@@ -531,7 +698,8 @@ import { VertexBlockNode } from './pbr.js';
    * Creates a vector constructor with the source value followed by zeros.
    * Example: vec4(src, 0, 0) for casting vec2 to vec4.
    */ create(pb) {
-        return pb[this.type](this.src.create(pb), ...Array.from({
+        // @ts-ignore
+        return pb[this.type](this.src.create(pb), ...this.fill ?? Array.from({
             length: this.cast
         }).fill(0));
     }
@@ -597,6 +765,7 @@ import { VertexBlockNode } from './pbr.js';
         if (coord instanceof PBShaderExp) {
             coordExp = coord;
         } else if (Array.isArray(coord)) {
+            // @ts-ignore
             coordExp = pb[`vec${coord.length}`](...coord);
         } else {
             throw new Error('Invalid texture coordinate');
@@ -681,6 +850,7 @@ import { VertexBlockNode } from './pbr.js';
    * Creates the uniform declaration in the global scope if not already present.
    */ create(pb) {
         if (!pb.getGlobalScope()[this.name]) {
+            // @ts-ignore
             pb.getGlobalScope()[this.name] = pb[this.type]().uniform(2);
         }
         return pb.getGlobalScope()[this.name];
@@ -721,24 +891,11 @@ import { VertexBlockNode } from './pbr.js';
  * 3. Track uniforms and behaviors
  * 4. Generate optimized shader code from the IR
  *
- * @example
- * ```typescript
- * const ir = new MaterialBlueprintIR(dag, materialHash);
- * if (ir.ok) {
- *   // Generate shader code
- *   const outputs = ir.create(programBuilder);
- *
- *   // Apply uniforms at runtime
- *   for (const uniform of ir.uniformValues) {
- *     material.setUniform(uniform.name, uniform.value);
- *   }
- * }
- * ```
- *
  * @public
  */ class MaterialBlueprintIR {
     /** The directed acyclic graph of material nodes */ _dag;
     /** Unique hash identifying this material configuration */ _hash;
+    /** Editor state snapshot at time of compilation */ _editorState;
     /** Array of all IR expressions in the graph */ _expressions;
     /** Map from graph node to IR expression index */ _expressionMap;
     /** Array of uniform scalar/vector values to be set at runtime */ _uniformValues;
@@ -750,11 +907,12 @@ import { VertexBlockNode } from './pbr.js';
    *
    * @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){
+   */ constructor(dag, hash, editorState){
         this._dag = dag ?? {
             nodeMap: {},
             roots: [],
@@ -765,6 +923,7 @@ import { VertexBlockNode } from './pbr.js';
             order: []
         };
         this._hash = hash;
+        this._editorState = editorState;
         this.compile();
     }
     /**
@@ -772,11 +931,14 @@ import { VertexBlockNode } from './pbr.js';
    *
    * @returns True if compilation produced valid outputs
    */ get ok() {
-        return this._outputs?.length > 0;
+        return this._outputs ? this._outputs.length > 0 : false;
     }
     /** Gets the unique hash for this material */ get hash() {
         return this._hash;
     }
+    /** Gets the editor state snapshot */ get editorState() {
+        return this._editorState;
+    }
     /** Gets the behavior flags indicating shader requirements */ get behaviors() {
         return this._behaviors;
     }
@@ -813,18 +975,20 @@ import { VertexBlockNode } from './pbr.js';
                 if (input.inputNode) {
                     this._outputs.push({
                         name,
-                        expr: this.ir(input.inputNode, input.inputId, input.originType).addRef()
-                    });
-                } else if (typeof input.defaultValue === 'number') {
-                    this._outputs.push({
-                        name,
-                        expr: new IRConstantf(input.defaultValue, '').addRef()
+                        expr: this.ir(input).addRef()
                     });
                 } else if (Array.isArray(input.defaultValue)) {
-                    this._outputs.push({
-                        name,
-                        expr: new IRConstantfv(input.defaultValue, '', `vec${input.defaultValue.length}`).addRef()
-                    });
+                    if (input.defaultValue.length === 1) {
+                        this._outputs.push({
+                            name,
+                            expr: new IRConstantf(input.defaultValue[0], '').addRef()
+                        });
+                    } else {
+                        this._outputs.push({
+                            name,
+                            expr: new IRConstantfv(input.defaultValue, '', `vec${input.defaultValue.length}`).addRef()
+                        });
+                    }
                 } else if (input.required) {
                     this._outputs = null;
                     return false;
@@ -904,12 +1068,20 @@ import { VertexBlockNode } from './pbr.js';
    * Handles automatic type casting when originType differs from node output type.
    *
    * @throws Error if type casting is invalid
-   */ ir(node, output, originType) {
+   */ ir(inputNode) {
+        const node = inputNode.inputNode;
+        const output = inputNode.inputId;
+        const originType = inputNode.originType;
+        const defaultValue = inputNode.defaultValue;
         let expr = null;
         if (node instanceof ConstantScalarNode) {
             expr = this.constantf(node, output);
         } else if (node instanceof ConstantVec2Node || node instanceof ConstantVec3Node || node instanceof ConstantVec4Node) {
             expr = this.constantfv(node, output);
+        } else if (node instanceof ConstantBooleanNode) {
+            expr = this.constantb(node, output);
+        } else if (node instanceof ConstantBVec2Node || node instanceof ConstantBVec3Node || node instanceof ConstantBVec4Node) {
+            expr = this.constantbv(node, output);
         } else if (node instanceof BaseTextureNode) {
             expr = this.constantTexture(node, output);
         } else if (node instanceof TextureSampleNode) {
@@ -918,6 +1090,14 @@ import { VertexBlockNode } from './pbr.js';
             expr = this.makeVector(node, output);
         } else if (node instanceof SwizzleNode) {
             expr = this.swizzle(node, output);
+        } else if (node instanceof CompComparisonNode) {
+            expr = this.comparison(node, output);
+        } else if (node instanceof AnyConditionNode) {
+            expr = this.any(node, output);
+        } else if (node instanceof AllConditionNode) {
+            expr = this.all(node, output);
+        } else if (node instanceof SelectionNode) {
+            expr = this.selection(node, output);
         } else if (node instanceof ResolveVertexPositionNode) {
             expr = this.resolveVertexPosition(node, output);
         } else if (node instanceof ResolveVertexNormalNode) {
@@ -996,7 +1176,7 @@ import { VertexBlockNode } from './pbr.js';
                     if (nOut > nOrg) {
                         return new IRSwizzle(expr, 'xyzw'.slice(0, nOrg));
                     } else {
-                        return new IRCast(expr, originType, nOrg - nOut);
+                        return new IRCast(expr, originType, nOrg - nOut, defaultValue?.slice(nOut - nOrg));
                     }
                 } else {
                     throw new Error(`Cannot cast type \`${outputType}\` to \`${originType}`);
@@ -1038,9 +1218,6 @@ import { VertexBlockNode } from './pbr.js';
         if (!ir.outputs[outputId]) {
             const output = node.outputs.find((v)=>v.id === outputId);
             ir.outputs[outputId] = ir;
-            if (typeof output.cast === 'number') {
-                ir.outputs[outputId] = new IRCast(ir, node.getOutputType(outputId), output.cast);
-            }
             if (output.swizzle) {
                 ir.outputs[outputId] = new IRSwizzle(ir.outputs[outputId], output.swizzle);
             }
@@ -1051,20 +1228,32 @@ import { VertexBlockNode } from './pbr.js';
         const params = [];
         for (const input of node.inputs){
             if (input.inputNode) {
-                params.push(this.ir(input.inputNode, input.inputId, input.originType));
+                params.push(this.ir(input));
             }
         }
         const funcName = node.getOutputType(output);
         return this.getOrCreateIRExpression(node, output, IRFunc, params, funcName);
     }
     /** Converts a swizzle node to IR */ swizzle(node, output) {
-        return this.getOrCreateIRExpression(node, output, IRSwizzle, this.ir(node.inputs[0].inputNode, node.inputs[0].inputId, node.inputs[0].originType), node.swizzle);
+        return this.getOrCreateIRExpression(node, output, IRSwizzle, this.ir(node.inputs[0]), node.swizzle);
+    }
+    /** Converts a comparison node to IR */ comparison(node, output) {
+        return this.getOrCreateIRExpression(node, output, IRComparison, this.ir(node.inputs[0]), this.ir(node.inputs[1]), node.mode);
+    }
+    /** Converts an any-condition node to IR */ any(node, output) {
+        return this.getOrCreateIRExpression(node, output, IRAny, this.ir(node.inputs[0]));
+    }
+    /** Converts an all-condition node to IR */ all(node, output) {
+        return this.getOrCreateIRExpression(node, output, IRAll, this.ir(node.inputs[0]));
+    }
+    /** Converts a selection node to IR */ selection(node, output) {
+        return this.getOrCreateIRExpression(node, output, IRSelection, this.ir(node.inputs[0]), this.ir(node.inputs[1]), this.ir(node.inputs[2]));
     }
     /** Converts a Transform node to IR */ transform(node, output) {
         const params = [];
         for (const input of node.inputs){
             if (input.inputNode) {
-                params.push(this.ir(input.inputNode, input.inputId, input.originType));
+                params.push(this.ir(input));
             }
         }
         return this.getOrCreateIRExpression(node, output, IRFunc, params, 'mul');
@@ -1073,31 +1262,31 @@ import { VertexBlockNode } from './pbr.js';
         const params = [];
         for (const input of node.inputs){
             if (input.inputNode) {
-                params.push(this.ir(input.inputNode, input.inputId, input.originType));
+                params.push(this.ir(input));
             }
         }
         const funcName = node.func;
         return this.getOrCreateIRExpression(node, output, IRFunc, params, funcName);
     }
     /** Converts a function output node to IR */ functionOutput(node, output) {
-        const input = this.ir(node.inputs[0].inputNode, node.inputs[0].inputId, node.inputs[0].originType);
+        const input = this.ir(node.inputs[0]);
         return this.getOrCreateIRExpression(node, output, IRFunctionOutput, input);
     }
     /** Converts a vertex color input node to IR */ vertexColor(node, output) {
         this._behaviors.useVertexColor = true;
-        return this.getOrCreateIRExpression(node, output, IRInput, (scope)=>scope.$inputs.zVertexColor);
+        return this.getOrCreateIRExpression(node, output, IRInput, (scope)=>scope.zVertexColor);
     }
     /** Converts a vertex UV input node to IR */ vertexUV(node, output) {
         this._behaviors.useVertexUV = true;
         return this.getOrCreateIRExpression(node, output, IRInput, (scope)=>{
-            return scope.$inputs.zVertexUV;
+            return scope.zVertexUV;
         });
     }
     /** Converts a vertex normal input node to IR */ vertexNormal(node, output) {
-        return this.getOrCreateIRExpression(node, output, IRInput, (scope)=>scope.$builder.getDevice().type === 'vertex' ? scope.$getVertexAttrib('normal') ?? ShaderHelper.resolveVertexNormal(scope) : scope.$inputs.zVertexNormal);
+        return this.getOrCreateIRExpression(node, output, IRInput, (scope)=>scope.$builder.getDevice().type === 'vertex' ? scope.$getVertexAttrib('normal') ?? ShaderHelper.resolveVertexNormal(scope) : scope.zVertexNormal);
     }
     /** Converts a vertex tangent input node to IR */ vertexTangent(node, output) {
-        return this.getOrCreateIRExpression(node, output, IRInput, (scope)=>scope.$builder.getDevice().type === 'vertex' ? scope.$getVertexAttrib('tangent') ?? ShaderHelper.resolveVertexTangent(scope) : scope.$inputs.zVertexTangent);
+        return this.getOrCreateIRExpression(node, output, IRInput, (scope)=>scope.$builder.getDevice().type === 'vertex' ? scope.$getVertexAttrib('tangent') ?? ShaderHelper.resolveVertexTangent(scope) : scope.zVertexTangent);
     }
     /** Converts a vertex binormal input node to IR */ vertexBinormal(node, output) {
         return this.getOrCreateIRExpression(node, output, IRInput, 'zVertexBinormal');
@@ -1174,7 +1363,7 @@ import { VertexBlockNode } from './pbr.js';
         ASSERT(!!input.inputNode);
         const type = input.inputNode.getOutputType(input.inputId);
         ASSERT(type === 'float' || type === 'vec2' || type === 'vec3');
-        params.push(this.ir(input.inputNode, input.inputId, input.originType));
+        params.push(this.ir(input));
         return this.getOrCreateIRExpression(node, output, IRFunc, params, (pb, ...params)=>{
             const scope = pb.getCurrentScope();
             const seed = params[0];
@@ -1187,7 +1376,7 @@ import { VertexBlockNode } from './pbr.js';
         ASSERT(!!input.inputNode);
         const type = input.inputNode.getOutputType(input.inputId);
         ASSERT(type === 'float' || type === 'vec2' || type === 'vec3');
-        params.push(this.ir(input.inputNode, input.inputId, input.originType));
+        params.push(this.ir(input));
         return this.getOrCreateIRExpression(node, output, IRFunc, params, (pb, ...params)=>{
             const scope = pb.getCurrentScope();
             const seed = params[0];
@@ -1200,7 +1389,7 @@ import { VertexBlockNode } from './pbr.js';
         ASSERT(!!input.inputNode);
         const type = input.inputNode.getOutputType(input.inputId);
         ASSERT(type === 'float' || type === 'vec2' || type === 'vec3');
-        params.push(this.ir(input.inputNode, input.inputId, input.originType));
+        params.push(this.ir(input));
         return this.getOrCreateIRExpression(node, output, IRFunc, params, (pb, ...params)=>{
             const scope = pb.getCurrentScope();
             const seed = params[0];
@@ -1211,7 +1400,7 @@ import { VertexBlockNode } from './pbr.js';
         const params = [];
         for (const input of node.inputs){
             if (input.inputNode) {
-                params.push(this.ir(input.inputNode, input.inputId, input.originType));
+                params.push(this.ir(input));
             }
         }
         return this.getOrCreateIRExpression(node, output, IRFunc, params, (pb, ...params)=>{
@@ -1238,7 +1427,7 @@ import { VertexBlockNode } from './pbr.js';
         const params = [];
         for (const input of node.inputs){
             if (input.inputNode) {
-                params.push(this.ir(input.inputNode, input.inputId, input.originType));
+                params.push(this.ir(input));
             }
         }
         return this.getOrCreateIRExpression(node, output, IRFunc, params, (pb, ...params)=>{
@@ -1274,7 +1463,7 @@ import { VertexBlockNode } from './pbr.js';
     }
     /** Converts a function call node to IR */ functionCall(node, output) {
         const args = node.inputs.map((input)=>{
-            return this.ir(input.inputNode, input.inputId, input.originType);
+            return this.ir(input);
         });
         return this.getOrCreateIRExpression(node, output, IRCallFunc, node, args);
     }
@@ -1297,12 +1486,31 @@ import { VertexBlockNode } from './pbr.js';
         ];
         return this.getOrCreateIRExpression(node, output, IRConstantfv, value, node.paramName, `vec${value.length}`);
     }
+    /** Converts a scalar boolean constant node to IR */ constantb(node, output) {
+        return this.getOrCreateIRExpression(node, output, IRConstantb, node.x);
+    }
+    /** Converts a boolean vector constant node to IR */ constantbv(node, output) {
+        const value = node instanceof ConstantBVec2Node ? [
+            node.x,
+            node.y
+        ] : node instanceof ConstantBVec3Node ? [
+            node.x,
+            node.y,
+            node.z
+        ] : [
+            node.x,
+            node.y,
+            node.z,
+            node.w
+        ];
+        return this.getOrCreateIRExpression(node, output, IRConstantbv, value);
+    }
     /** Converts a texture constant node to IR */ constantTexture(node, output) {
         return this.getOrCreateIRExpression(node, output, IRConstantTexture, node.paramName, node.textureId, node.getOutputType(1), node.sRGB, node.addressU, node.addressV, node.filterMin, node.filterMag, node.filterMip);
     }
     /** Converts a texture sample node to IR */ textureSample(node, output) {
-        const tex = this.ir(node.inputs[0].inputNode, node.inputs[0].inputId);
-        const coord = this.ir(node.inputs[1].inputNode, node.inputs[1].inputId);
+        const tex = this.ir(node.inputs[0]);
+        const coord = this.ir(node.inputs[1]);
         return this.getOrCreateIRExpression(node, output, IRSampleTexture, tex, coord, node.samplerType);
     }
 }