@zephyr3d/scene 0.9.5 → 0.9.7

package/dist/material/pbrblueprint.js

@@ -1,61 +1,43 @@
-import { applyMaterialMixins, MeshMaterial } from './meshmaterial.js';
+import { DRef, Vector4 } from '@zephyr3d/base';
 import { ShaderHelper } from './shader/helper.js';
-import { RENDER_PASS_TYPE_LIGHT, MaterialVaryingFlags } from '../values.js';
-import { Vector3, Vector2, DRef, Vector4 } from '@zephyr3d/base';
-import { mixinPBRBluePrint } from './mixins/lightmodel/pbrblueprintmixin.js';
 import { MaterialBlueprintIR } from '../utility/blueprint/material/ir.js';
 import { PBRBlockNode, VertexBlockNode } from '../utility/blueprint/material/pbr.js';
+import { PBRMetallicRoughnessMaterial } from './pbrmr.js';
 
-const PBR_REFLECTION_MODE = {
-    none: 0,
-    ggx: 1,
-    anisotropic: 2,
-    glint: 3
-};
-/**
- * Physically-based rendering material driven by blueprint graphs.
- *
- * @remarks
- * This material extends {@link MeshMaterial} with PBR behavior via
- * {@link mixinPBRBluePrint}, and uses {@link MaterialBlueprintIR}
- * graphs for both vertex and fragment stages.
- *
- * - The **vertex blueprint IR** (`vertexIR`) controls vertex
- *   transformations and per-vertex data.
- * - The **fragment blueprint IR** (`fragmentIR`) produces inputs
- *   for the PBR shading model (albedo, roughness, metalness, etc.).
- *
- * Uniform values and textures for the blueprints are provided via
- * {@link PBRBluePrintMaterial.uniformValues} and
- * {@link PBRBluePrintMaterial.uniformTextures}.
- *
- * @public
- */ class PBRBluePrintMaterial extends applyMaterialMixins(MeshMaterial, mixinPBRBluePrint) {
-    /** @internal */ static FEATURE_VERTEX_COLOR = this.defineFeature();
-    /** @internal */ static FEATURE_VERTEX_UV = this.defineFeature();
-    /** @internal */ static FEATURE_SUBSURFACE_SCATTERING = this.defineFeature();
+const DEFAULT_OUTPUT_NAMES = [
+    'BaseColor',
+    'Metallic',
+    'Roughness',
+    'Specular',
+    'Emissive',
+    'Normal',
+    'Tangent',
+    'Opacity',
+    'SpecularWeight',
+    'AO'
+];
+/**
+ * Physically-based rendering material driven by blueprint graphs, but shaded by the
+ * same PBR metallic/roughness backend used by {@link PBRMetallicRoughnessMaterial}.
+ *
+ * @remarks
+ * The blueprint graph only produces surface inputs. Final direct/indirect lighting,
+ * transmission, clearcoat, sheen, iridescence and anisotropic reflection still run
+ * through the standard PBRM backend so imported GLTF materials and blueprint materials
+ * stay on the same shading path.
+ *
+ * @public
+ */ class PBRBluePrintMaterial extends PBRMetallicRoughnessMaterial {
+    /** @internal */ static FEATURE_BLUEPRINT_VERTEX_COLOR = this.defineFeature();
+    /** @internal */ static FEATURE_BLUEPRINT_VERTEX_UV = this.defineFeature();
     /** @internal */ _irFrag;
     /** @internal */ _irVertex;
     /** @internal */ _uniformValues;
     /** @internal */ _uniformTextures;
-    /** @internal */ _reflectionMode;
-    /** @internal */ _subsurfaceColor;
-    /** @internal */ _subsurfaceScale;
-    /** @internal */ _subsurfacePower;
-    /** @internal */ _subsurfaceIntensity;
-    /** @internal */ _anisotropy;
-    /** @internal */ _anisotropyDirection;
-    /** @internal */ _anisotropyDirectionScaleBias;
-    /**
-   * Creates a new {@link PBRBluePrintMaterial} instance.
-   *
-   * @param irFrag - Optional fragment blueprint IR. If omitted, a default
-   *   IR containing a single {@link PBRBlockNode} is created.
-   * @param irVertex - Optional vertex blueprint IR. If omitted, a default
-   *   IR containing a single {@link VertexBlockNode} is created.
-   * @param uniformValues - Optional initial list of uniform value descriptors.
-   * @param uniformTextures - Optional initial list of texture uniform descriptors.
-   */ constructor(irFrag, irVertex, uniformValues, uniformTextures){
+    /** @internal */ _connectedOutputs;
+    /** @internal */ _vertexUsesColor;
+    /** @internal */ _vertexUsesUV;
+    constructor(irFrag, irVertex, uniformValues, uniformTextures){
         super();
         this._irFrag = irFrag ?? new MaterialBlueprintIR({
             nodeMap: {
@@ -115,126 +97,34 @@ const PBR_REFLECTION_MODE = {
         });
         this._uniformValues = uniformValues ?? [];
         this._uniformTextures = uniformTextures ?? [];
-        this._reflectionMode = 'ggx';
-        this._subsurfaceColor = new Vector3(1, 0.3, 0.2);
-        this._subsurfaceScale = 0.5;
-        this._subsurfacePower = 1.5;
-        this._subsurfaceIntensity = 0.5;
-        this._anisotropy = 0.75;
-        this._anisotropyDirection = 0;
-        this._anisotropyDirectionScaleBias = new Vector2(1, 0);
-        this.useFeature(PBRBluePrintMaterial.FEATURE_SUBSURFACE_SCATTERING, false);
-        this.useFeature(PBRBluePrintMaterial.FEATURE_VERTEX_COLOR, this._irVertex.behaviors.useVertexColor);
-        this.useFeature(PBRBluePrintMaterial.FEATURE_VERTEX_UV, this._irVertex.behaviors.useVertexUV);
-    }
-    get reflectionMode() {
-        return this._reflectionMode;
-    }
-    set reflectionMode(val) {
-        if (val !== this._reflectionMode) {
-            this._reflectionMode = val;
-            this.uniformChanged();
-        }
-    }
-    get subsurfaceScattering() {
-        return this.featureUsed(PBRBluePrintMaterial.FEATURE_SUBSURFACE_SCATTERING);
-    }
-    set subsurfaceScattering(val) {
-        this.useFeature(PBRBluePrintMaterial.FEATURE_SUBSURFACE_SCATTERING, !!val);
-    }
-    get subsurfaceColor() {
-        return this._subsurfaceColor;
-    }
-    set subsurfaceColor(val) {
-        if (!val.equalsTo(this._subsurfaceColor)) {
-            this._subsurfaceColor.set(val);
-            this.uniformChanged();
-        }
-    }
-    get subsurfaceScale() {
-        return this._subsurfaceScale;
-    }
-    set subsurfaceScale(val) {
-        if (val !== this._subsurfaceScale) {
-            this._subsurfaceScale = val;
-            this.uniformChanged();
-        }
-    }
-    get subsurfacePower() {
-        return this._subsurfacePower;
-    }
-    set subsurfacePower(val) {
-        if (val !== this._subsurfacePower) {
-            this._subsurfacePower = val;
-            this.uniformChanged();
-        }
-    }
-    get subsurfaceIntensity() {
-        return this._subsurfaceIntensity;
-    }
-    set subsurfaceIntensity(val) {
-        if (val !== this._subsurfaceIntensity) {
-            this._subsurfaceIntensity = val;
-            this.uniformChanged();
-        }
+        this._connectedOutputs = new Set();
+        this._vertexUsesColor = false;
+        this._vertexUsesUV = false;
+        this.syncBlueprintMetadata();
     }
-    get anisotropy() {
-        return this._anisotropy;
-    }
-    set anisotropy(val) {
-        const clamped = Math.max(-0.95, Math.min(0.95, val));
-        if (clamped !== this._anisotropy) {
-            this._anisotropy = clamped;
-            this.uniformChanged();
-        }
-    }
-    get anisotropyDirection() {
-        return this._anisotropyDirection;
-    }
-    set anisotropyDirection(val) {
-        if (val !== this._anisotropyDirection) {
-            this._anisotropyDirection = val;
-            this.uniformChanged();
-        }
-    }
-    get anisotropyDirectionScaleBias() {
-        return this._anisotropyDirectionScaleBias;
-    }
-    set anisotropyDirectionScaleBias(val) {
-        if (!val.equalsTo(this._anisotropyDirectionScaleBias)) {
-            this._anisotropyDirectionScaleBias.set(val);
-            this.uniformChanged();
-        }
-    }
-    /**
-   * Gets the fragment blueprint IR.
-   */ get fragmentIR() {
+    get fragmentIR() {
         return this._irFrag;
     }
     set fragmentIR(ir) {
         if (ir && ir !== this._irFrag) {
             this._irFrag = ir;
+            this.syncBlueprintMetadata();
             this.clearCache();
             this.optionChanged(true);
         }
     }
-    /**
-   * Gets the vertex blueprint IR.
-   */ get vertexIR() {
+    get vertexIR() {
         return this._irVertex;
     }
     set vertexIR(ir) {
         if (ir && ir !== this._irVertex) {
             this._irVertex = ir;
-            this.useFeature(PBRBluePrintMaterial.FEATURE_VERTEX_COLOR, this._irVertex.behaviors.useVertexColor);
-            this.useFeature(PBRBluePrintMaterial.FEATURE_VERTEX_UV, this._irVertex.behaviors.useVertexUV);
+            this.syncBlueprintMetadata();
             this.clearCache();
             this.optionChanged(true);
         }
     }
-    /**
-   * Gets the list of uniform value descriptors used by the blueprints.
-   */ get uniformValues() {
+    get uniformValues() {
         return this._uniformValues;
     }
     set uniformValues(val) {
@@ -243,262 +133,535 @@ const PBR_REFLECTION_MODE = {
             }));
         this.uniformChanged();
     }
-    /**
-   * Gets the list of texture uniform descriptors used by the blueprints.
-   */ get uniformTextures() {
+    get uniformTextures() {
         return this._uniformTextures;
     }
     set uniformTextures(val) {
         if (val !== this._uniformTextures) {
-            const newUniforms = val.map((v)=>({
-                    finalTexture: new DRef(v.finalTexture.get()),
+            const newUniforms = (val ?? []).map((v)=>({
+                    finalTexture: new DRef(v.finalTexture?.get() ?? null),
                     finalSampler: v.finalSampler,
+                    inFragmentShader: v.inFragmentShader,
+                    inVertexShader: v.inVertexShader,
+                    magFilter: v.magFilter,
+                    minFilter: v.minFilter,
+                    mipFilter: v.mipFilter,
                     name: v.name,
                     params: v.params?.clone() ?? Vector4.zero(),
+                    sRGB: v.sRGB,
                     texture: v.texture,
                     type: v.type,
-                    sRGB: v.sRGB,
                     wrapS: v.wrapS,
-                    wrapT: v.wrapT,
-                    inFragmentShader: v.inFragmentShader,
-                    inVertexShader: v.inVertexShader,
-                    minFilter: v.minFilter,
-                    magFilter: v.magFilter,
-                    mipFilter: v.mipFilter
+                    wrapT: v.wrapT
                 }));
             for (const u of this._uniformTextures){
-                u.finalTexture.dispose();
+                u.finalTexture?.dispose();
             }
             this._uniformTextures = newUniforms;
             this.uniformChanged();
         }
     }
-    /**
-   * Creates a deep copy of this material.
-   *
-   * @remarks
-   * The clone shares the same vertex/fragment IR references and copies
-   * the current blueprint uniform descriptors, then calls `copyFrom`
-   * to copy base-class and mixin state.
-   *
-   * @returns A new {@link PBRBluePrintMaterial} instance.
-   */ clone() {
+    hasConnectedOutput(name) {
+        return this._connectedOutputs.has(name);
+    }
+    clone() {
         const other = new PBRBluePrintMaterial(this._irFrag, this._irVertex, this._uniformValues, this._uniformTextures);
         other.copyFrom(this);
         return other;
     }
     copyFrom(other) {
         super.copyFrom(other);
-        this.reflectionMode = other.reflectionMode;
-        this.subsurfaceScattering = other.subsurfaceScattering;
-        this.subsurfaceColor = other.subsurfaceColor;
-        this.subsurfaceScale = other.subsurfaceScale;
-        this.subsurfacePower = other.subsurfacePower;
-        this.subsurfaceIntensity = other.subsurfaceIntensity;
-        this.anisotropy = other.anisotropy;
-        this.anisotropyDirection = other.anisotropyDirection;
-        this.anisotropyDirectionScaleBias = other.anisotropyDirectionScaleBias;
-    }
-    /**
-   * Builds the vertex shader for this PBR blueprint material.
-   *
-   * @param scope - The current vertex shader function scope.
-   */ vertexShader(scope) {
+        if (other instanceof PBRBluePrintMaterial) {
+            this.fragmentIR = other.fragmentIR;
+            this.vertexIR = other.vertexIR;
+            this.uniformValues = other.uniformValues;
+            this.uniformTextures = other.uniformTextures;
+        }
+    }
+    vertexShader(scope) {
         super.vertexShader(scope);
         const pb = scope.$builder;
-        scope.$inputs.zVertexPos = pb.vec3().attrib('position');
-        scope.$inputs.zVertexNormal = pb.vec3().attrib('normal');
-        scope.$inputs.zVertexTangent = pb.vec4().attrib('tangent');
-        if (this.featureUsed(PBRBluePrintMaterial.FEATURE_VERTEX_COLOR)) {
-            scope.$inputs.zVertexColor = pb.vec4().attrib('diffuse');
+        scope.zVertexColor = this.getBlueprintVertexColor(scope);
+        scope.zVertexUV = this.getBlueprintVertexUV(scope);
+        scope.zVertexNormal = scope.$outputs.wNorm ?? pb.vec3(0, 0, 1);
+        scope.zVertexTangent = scope.$outputs.wTangent ?? pb.vec3(1, 0, 0);
+        scope.zVertexBinormal = scope.$outputs.wBinormal ?? pb.vec3(0, 1, 0);
+        scope.zWorldPos = scope.$outputs.worldPos;
+        if (this._vertexUsesColor && !scope.$outputs.zOutDiffuse) {
+            scope.$outputs.zOutDiffuse = scope.zVertexColor;
         }
-        if (this.featureUsed(PBRBluePrintMaterial.FEATURE_VERTEX_UV)) {
-            scope.$inputs.zVertexUV = pb.vec2().attrib('texCoord0');
+        if (this._vertexUsesUV) {
+            scope.$outputs.zVertexUV = scope.zVertexUV;
         }
         for (const u of [
             ...this._uniformValues,
             ...this._uniformTextures
         ]){
             if (u.inVertexShader) {
-                // @ts-ignore
+                // @ts-ignore dynamic shader type constructor
                 pb.getGlobalScope()[u.name] = pb[u.type]().uniform(2);
             }
         }
         const outputs = this._irVertex.create(pb);
-        scope.$l.oPos = this.getOutput(outputs, 'Position') ?? ShaderHelper.resolveVertexPosition(scope);
+        if (!outputs) {
+            return;
+        }
+        const vertexOut = this.toVertexOutputMap(outputs);
         const worldMatrix = ShaderHelper.getWorldMatrix(scope);
-        scope.$outputs.worldPos = pb.mul(worldMatrix, pb.vec4(scope.oPos, 1)).xyz;
-        scope.$l.csPos = pb.mul(ShaderHelper.getViewProjectionMatrix(scope), pb.vec4(scope.$outputs.worldPos, 1));
-        ShaderHelper.setClipSpacePosition(scope, scope.csPos);
-        scope.$outputs.zVertexColor = this.getOutput(outputs, 'Color') ?? (this.featureUsed(PBRBluePrintMaterial.FEATURE_VERTEX_COLOR) ? scope.$inputs.zVertexColor : pb.vec4(1));
-        scope.$outputs.zVertexUV = this.getOutput(outputs, 'UV') ?? (this.featureUsed(PBRBluePrintMaterial.FEATURE_VERTEX_UV) ? scope.$inputs.zVertexUV : pb.vec2(0));
-        scope.$l.oNorm = this.getOutput(outputs, 'Normal') ?? ShaderHelper.resolveVertexNormal(scope);
-        scope.$outputs.zVertexNormal = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.oNorm, 0)).xyz;
-        scope.$l.oTangent = this.getOutput(outputs, 'Tangent') ?? ShaderHelper.resolveVertexTangent(scope);
-        scope.$outputs.zVertexTangent = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.oTangent.xyz, 0)).xyz;
-        scope.$outputs.zVertexBinormal = pb.mul(pb.cross(scope.$outputs.zVertexNormal, scope.$outputs.zVertexTangent), scope.oTangent.w);
+        if (vertexOut.Position) {
+            scope.$l.oPos = vertexOut.Position;
+            scope.$outputs.worldPos = pb.mul(worldMatrix, pb.vec4(scope.oPos, 1)).xyz;
+            scope.zWorldPos = scope.$outputs.worldPos;
+            scope.$l.csPos = pb.mul(ShaderHelper.getViewProjectionMatrix(scope), pb.vec4(scope.$outputs.worldPos, 1));
+            ShaderHelper.setClipSpacePosition(scope, scope.csPos);
+        }
+        if (vertexOut.Color) {
+            scope.zVertexColor = this.toVec4(scope, vertexOut.Color, 1);
+            if (scope.$outputs.zOutDiffuse) {
+                scope.$outputs.zOutDiffuse = scope.zVertexColor;
+            }
+        }
+        if (vertexOut.UV) {
+            scope.zVertexUV = this.toVec2(scope, vertexOut.UV);
+            if (this._vertexUsesUV) {
+                scope.$outputs.zVertexUV = scope.zVertexUV;
+            }
+        }
+        if (vertexOut.Normal) {
+            scope.$l.oNorm = this.toVec3(scope, vertexOut.Normal);
+            scope.$outputs.wNorm = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.oNorm, 0)).xyz;
+            scope.zVertexNormal = scope.$outputs.wNorm;
+        }
+        if (vertexOut.Tangent) {
+            const tangent = vertexOut.Tangent;
+            scope.$l.oTangent = tangent.getTypeName() === 'vec4' ? tangent : pb.vec4(this.toVec3(scope, tangent), 1);
+            scope.$outputs.wTangent = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.oTangent.xyz, 0)).xyz;
+            scope.$outputs.wBinormal = pb.mul(pb.cross(scope.$outputs.wNorm, scope.$outputs.wTangent), scope.oTangent.w);
+            scope.zVertexTangent = scope.$outputs.wTangent;
+            scope.zVertexBinormal = scope.$outputs.wBinormal;
+        }
         for (const outputName of [
             'Output1',
             'Output2',
             'Output3',
             'Output4'
         ]){
-            const output = this.getOutput(outputs, outputName);
+            const output = outputs.find((output)=>output.name === outputName)?.exp;
             if (output) {
                 scope.$outputs[outputName] = output;
             }
         }
     }
-    /**
-   * Builds the fragment shader for this PBR blueprint material.
-   *
-   * @param scope - The current fragment shader function scope.
-   */ fragmentShader(scope) {
-        super.fragmentShader(scope);
+    fragmentShader(scope) {
         const pb = scope.$builder;
-        if (this.subsurfaceScattering && this.needFragmentColor() && this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
-            scope.zSubsurfaceColor = pb.vec3().uniform(2);
-            scope.zSubsurfaceScale = pb.float().uniform(2);
-            scope.zSubsurfacePower = pb.float().uniform(2);
-            scope.zSubsurfaceIntensity = pb.float().uniform(2);
-        }
-        if (this.needFragmentColor()) {
-            scope.zAnisotropy = pb.float().uniform(2);
-            scope.zAnisotropyDirection = pb.float().uniform(2);
-            scope.zAnisotropyDirectionScaleBias = pb.vec2().uniform(2);
+        if (this.needFragmentColorInput()) {
             for (const u of [
                 ...this._uniformValues,
                 ...this._uniformTextures
             ]){
                 if (u.inFragmentShader) {
-                    // @ts-ignore
+                    // @ts-ignore dynamic shader type constructor
                     pb.getGlobalScope()[u.name] = pb[u.type]().uniform(2);
                 }
             }
-            scope.$l.viewVec = this.calculateViewVector(scope, scope.$inputs.worldPos);
-            scope.$l.commonData = this.getCommonDatasStruct(scope)();
-            this.getCommonData(scope, scope.commonData, scope.viewVec, scope.$inputs.worldPos, scope.$inputs.zVertexNormal, scope.$inputs.zVertexTangent, scope.$inputs.zVertexBinormal, scope.$inputs.zVertexColor, scope.$inputs.zVertexUV, this._irFrag);
-            if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
-                if (this.drawContext.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS) {
-                    scope.$l.outRoughness = pb.vec4();
-                    scope.$l.litColor = this.PBRLight(scope, scope.$inputs.worldPos, scope.viewVec, scope.commonData, scope.outRoughness);
-                    if (this.subsurfaceScattering) {
-                        scope.litColor = this.applySubsurfaceScattering(scope, scope.litColor, scope.commonData.albedo.rgb, scope.commonData.normal, scope.viewVec);
-                    }
-                    this.outputFragmentColor(scope, scope.$inputs.worldPos, scope.litColor, scope.outRoughness, pb.vec4(pb.add(pb.mul(scope.commonData.normal, 0.5), pb.vec3(0.5)), 1));
-                } else {
-                    scope.$l.litColor = this.PBRLight(scope, scope.$inputs.worldPos, scope.viewVec, scope.commonData);
-                    if (this.subsurfaceScattering) {
-                        scope.litColor = this.applySubsurfaceScattering(scope, scope.litColor, scope.commonData.albedo.rgb, scope.commonData.normal, scope.viewVec);
-                    }
-                    this.outputFragmentColor(scope, scope.$inputs.worldPos, scope.litColor);
+            scope.zVertexColor = scope.$inputs.zOutDiffuse ?? pb.vec4(1);
+            scope.zVertexUV = scope.$inputs.zVertexUV ?? pb.vec2(0);
+            scope.zVertexNormal = scope.$inputs.wNorm ?? pb.vec3(0, 0, 1);
+            scope.zVertexTangent = scope.$inputs.wTangent ?? pb.vec3(1, 0, 0);
+            scope.zVertexBinormal = scope.$inputs.wBinormal ?? pb.vec3(0, 1, 0);
+            scope.zWorldPos = scope.$inputs.worldPos;
+        }
+        super.fragmentShader(scope);
+    }
+    applyUniformValues(bindGroup, ctx, pass) {
+        super.applyUniformValues(bindGroup, ctx, pass);
+        if (this.needFragmentColorInput(ctx)) {
+            for (const u of this._uniformValues){
+                bindGroup.setValue(u.name, u.finalValue);
+            }
+            for (const u of this._uniformTextures){
+                const texture = u.finalTexture?.get();
+                if (texture) {
+                    bindGroup.setTexture(u.name, texture, u.finalSampler);
                 }
-            } else {
-                this.outputFragmentColor(scope, scope.$inputs.worldPos, scope.commonData.albedo);
             }
+        }
+    }
+    createProgram(ctx, pass) {
+        return super.createProgram(ctx, pass);
+    }
+    _createHash() {
+        return `${super._createHash()}:${this._irFrag.hash}:${this._irVertex.hash}:${this._connectedOutputHash()}`;
+    }
+    onDispose() {
+        super.onDispose();
+        for (const u of this._uniformTextures){
+            u.finalTexture?.dispose();
+        }
+    }
+    calculateAlbedoColor(scope, uv) {
+        const baseColor = this.getBlueprintOutput(scope, 'BaseColor');
+        const opacity = this.getBlueprintOutput(scope, 'Opacity');
+        if (baseColor !== undefined) {
+            const pb = scope.$builder;
+            return pb.vec4(this.toVec3(scope, baseColor), opacity ?? 1);
+        }
+        const albedo = super.calculateAlbedoColor(scope, uv);
+        if (opacity !== undefined) {
+            const pb = scope.$builder;
+            return pb.vec4(albedo.rgb, opacity);
+        }
+        return albedo;
+    }
+    calculateMetallic(scope, albedo, normal) {
+        const value = this.getBlueprintOutput(scope, 'Metallic');
+        if (value !== undefined) {
+            return this.toFloat(scope, value);
+        }
+        return super.calculateMetallic(scope, albedo, normal);
+    }
+    calculateRoughness(scope, albedo, normal) {
+        const value = this.getBlueprintOutput(scope, 'Roughness');
+        if (value !== undefined) {
+            return this.toFloat(scope, value);
+        }
+        return super.calculateRoughness(scope, albedo, normal);
+    }
+    calculateSpecularFactor(scope, albedo, normal) {
+        const pb = scope.$builder;
+        const base = super.calculateSpecularFactor(scope, albedo, normal);
+        const specular = this.getBlueprintOutput(scope, 'Specular');
+        const weight = this.getBlueprintOutput(scope, 'SpecularWeight');
+        if (specular !== undefined || weight !== undefined) {
+            return pb.vec4(specular !== undefined ? this.toVec3(scope, specular) : base.rgb, weight ?? base.a);
+        }
+        return base;
+    }
+    calculateEmissiveColor(scope) {
+        const emissive = this.getBlueprintOutput(scope, 'Emissive');
+        if (emissive !== undefined) {
+            return this.toVec3(scope, emissive);
+        }
+        return super.calculateEmissiveColor(scope);
+    }
+    calculateNormalAndTBN(scope, worldPos, worldNormal, worldTangent, worldBinormal) {
+        const outputNormal = this.getBlueprintOutput(scope, 'Normal');
+        const outputTangent = this.getBlueprintOutput(scope, 'Tangent');
+        if (outputNormal === undefined && outputTangent === undefined) {
+            return super.calculateNormalAndTBN(scope, worldPos, worldNormal, worldTangent, worldBinormal);
+        }
+        const pb = scope.$builder;
+        const NormalStruct = pb.defineStruct([
+            pb.mat3('TBN'),
+            pb.vec3('normal')
+        ]);
+        const funcName = 'Z_calculateBlueprintNormalAndTBN';
+        const that = this;
+        pb.func(funcName, [
+            pb.vec3('worldPos'),
+            pb.vec3('worldNormal'),
+            pb.vec3('worldTangent'),
+            pb.vec3('worldBinormal'),
+            pb.vec3('surfaceNormal'),
+            pb.vec3('surfaceTangent')
+        ], function() {
+            this.$l.TBN = that.calculateTBN(this, this.worldPos, this.worldNormal, this.worldTangent, this.worldBinormal);
+            this.$l.ng = this.TBN[2];
+            this.$l.t = this.TBN[0];
+            this.$l.b = this.TBN[1];
+            this.$if(pb.greaterThan(pb.length(this.surfaceTangent), 0.0001), function() {
+                this.$l.t_ = pb.normalize(this.surfaceTangent);
+                this.t = pb.normalize(pb.sub(this.t_, pb.mul(this.ng, pb.dot(this.ng, this.t_))));
+                this.b = pb.normalize(pb.cross(this.ng, this.t));
+            });
+            this.TBN = pb.mat3(this.t, this.b, this.ng);
+            this.$l.surfaceNormalTS = this.surfaceNormal;
+            this.$if(pb.lessThanEqual(pb.length(this.surfaceNormalTS), 0.0001), function() {
+                this.surfaceNormalTS = pb.vec3(0, 0, 1);
+            });
+            this.$l.surfaceNormalWS = pb.normalize(pb.mul(this.TBN, this.surfaceNormalTS));
+            this.$return(NormalStruct(this.TBN, this.surfaceNormalWS));
+        });
+        return pb.getGlobalScope()[funcName](worldPos, worldNormal ?? scope.zVertexNormal, worldTangent ?? scope.zVertexTangent, worldBinormal ?? scope.zVertexBinormal, outputNormal !== undefined ? this.toVec3(scope, outputNormal) : pb.vec3(0, 0, 1), outputTangent !== undefined ? this.toVec3(scope, outputTangent) : pb.vec3(0));
+    }
+    indirectLighting(scope, normal, viewVec, commonData, outColor, outRoughness, outDiffuseColor) {
+        const ao = this.getBlueprintOutput(scope, 'AO');
+        if (ao === undefined) {
+            super.indirectLighting(scope, normal, viewVec, commonData, outColor, outRoughness, outDiffuseColor);
+            return;
+        }
+        const pb = scope.$builder;
+        const funcName = `Z_applyBlueprintAO${outDiffuseColor ? '_D' : ''}`;
+        pb.func(funcName, [
+            pb.vec3('outColor').inout(),
+            ...outDiffuseColor ? [
+                pb.vec3('outDiffuseColor').inout()
+            ] : [],
+            pb.float('ao')
+        ], function() {
+            this.outColor = pb.mul(this.outColor, this.ao);
+            if (outDiffuseColor) {
+                this.outDiffuseColor = pb.mul(this.outDiffuseColor, this.ao);
+            }
+        });
+        super.indirectLighting(scope, normal, viewVec, commonData, outColor, outRoughness, outDiffuseColor);
+        if (outDiffuseColor) {
+            pb.getGlobalScope()[funcName](outColor, outDiffuseColor, ao);
         } else {
-            this.outputFragmentColor(scope, scope.$inputs.worldPos, null);
-        }
-    }
-    /**
-   * Applies runtime uniform values and textures to the given bind group.
-   *
-   * @remarks
-   * - Calls the base implementation first to bind standard mesh/PBR uniforms.
-   * - If fragment color is needed for the current context, all blueprint
-   *   scalar/vector uniform values and textures are then bound by name.
-   *
-   * @param bindGroup - The bind group to which material resources are bound.
-   * @param ctx - The current draw context.
-   * @param pass - Index of the active render pass.
-   */ applyUniformValues(bindGroup, ctx, pass) {
-        super.applyUniformValues(bindGroup, ctx, pass);
-        if (this.needFragmentColor(ctx)) {
-            bindGroup.setValue('zReflectionMode', PBR_REFLECTION_MODE[this._reflectionMode]);
-            bindGroup.setValue('zAnisotropy', this._anisotropy);
-            bindGroup.setValue('zAnisotropyDirection', this._anisotropyDirection);
-            bindGroup.setValue('zAnisotropyDirectionScaleBias', this._anisotropyDirectionScaleBias);
-            if (this.subsurfaceScattering && ctx.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
-                bindGroup.setValue('zSubsurfaceColor', this._subsurfaceColor);
-                bindGroup.setValue('zSubsurfaceScale', this._subsurfaceScale);
-                bindGroup.setValue('zSubsurfacePower', this._subsurfacePower);
-                bindGroup.setValue('zSubsurfaceIntensity', this._subsurfaceIntensity);
+            pb.getGlobalScope()[funcName](outColor, ao);
+        }
+    }
+    syncBlueprintMetadata() {
+        this._connectedOutputs = this.collectConnectedOutputs(this._irFrag, PBRBlockNode);
+        const fragmentUsesColor = this._irFrag.behaviors.useVertexColor;
+        const fragmentUsesUV = this._irFrag.behaviors.useVertexUV;
+        const vertexUsesColor = this._irVertex.behaviors.useVertexColor;
+        const vertexUsesUV = this._irVertex.behaviors.useVertexUV;
+        this._vertexUsesColor = fragmentUsesColor || vertexUsesColor;
+        this._vertexUsesUV = fragmentUsesUV || vertexUsesUV;
+        this.useFeature(PBRBluePrintMaterial.FEATURE_BLUEPRINT_VERTEX_COLOR, this._vertexUsesColor);
+        this.useFeature(PBRBluePrintMaterial.FEATURE_BLUEPRINT_VERTEX_UV, this._vertexUsesUV);
+    }
+    collectConnectedOutputs(ir, rootCtor) {
+        const outputs = new Set();
+        for (const rootId of ir.DAG.roots){
+            const rootNode = ir.DAG.nodeMap[rootId];
+            if (!(rootNode instanceof rootCtor)) {
+                continue;
+            }
+            for (const input of rootNode.inputs){
+                if (input.inputNode) {
+                    outputs.add(input.name);
+                }
             }
         }
-        for (const u of this._uniformValues){
-            if (u.inVertexShader || this.needFragmentColor(ctx)) {
-                bindGroup.setValue(u.name, u.finalValue);
+        return outputs;
+    }
+    getBlueprintVertexColor(scope) {
+        const pb = scope.$builder;
+        if (this.vertexColor) {
+            return this.getVertexColor(scope);
+        }
+        if (this._vertexUsesColor) {
+            if (scope.$inputs.zDiffuse) {
+                return scope.$inputs.zDiffuse;
+            }
+            if (scope.$getVertexAttrib('diffuse')) {
+                return scope.$getVertexAttrib('diffuse');
             }
+            scope.$inputs.zDiffuse = pb.vec4().attrib('diffuse');
+            return scope.$inputs.zDiffuse;
         }
-        for (const u of this._uniformTextures){
-            if (u.inVertexShader || this.needFragmentColor(ctx)) {
-                bindGroup.setTexture(u.name, u.finalTexture.get(), u.finalSampler);
+        return pb.vec4(1);
+    }
+    getBlueprintVertexUV(scope) {
+        const pb = scope.$builder;
+        if (this._vertexUsesUV) {
+            if (scope.$inputs.zVertexUV) {
+                return scope.$inputs.zVertexUV;
             }
+            if (scope.$getVertexAttrib('texCoord0')) {
+                return scope.$getVertexAttrib('texCoord0');
+            }
+            scope.$inputs.zVertexUV = pb.vec2().attrib('texCoord0');
+            return scope.$inputs.zVertexUV;
+        }
+        if (this.albedoTexture) {
+            return this.getAlbedoTexCoord(scope) ?? pb.vec2(0);
         }
+        return pb.vec2(0);
     }
-    /**
-   * Creates a unique hash string used for program caching.
-   *
-   * @remarks
-   * The hash includes:
-   * - The base material hash (`super._createHash()`).
-   * - The fragment IR hash.
-   * - The vertex IR hash.
-   *
-   * Different blueprint graphs will therefore produce different programs.
-   *
-   * @returns A hash string that uniquely identifies this material configuration.
-   */ _createHash() {
-        return `${super._createHash()}:${this._irFrag.hash}:${this._irVertex.hash}`;
-    }
-    /**
-   * Creates the GPU program for this blueprint PBR material.
-   *
-   * @remarks
-   * This calls the base implementation and returns its result.
-   * Commented-out `console.log` lines are provided for debugging the
-   * generated vertex and fragment shader sources.
-   *
-   * @param ctx - The current draw context.
-   * @param pass - Index of the active render pass.
-   * @returns The created GPU program.
-   */ createProgram(ctx, pass) {
-        const program = super.createProgram(ctx, pass);
-        //console.log(program.getShaderSource('vertex'));
-        //console.log(program.getShaderSource('fragment'));
-        return program;
-    }
-    /**
-   * Disposes resources associated with this material.
-   *
-   * @remarks
-   * - Calls the base `onDispose` to clean up inherited resources.
-   * - Disposes all `finalTexture` references from the blueprint
-   *   texture uniform descriptors.
-   *
-   * This method is intended to be called by the engine's resource
-   * management system rather than directly by user code.
-   */ onDispose() {
-        super.onDispose();
-        for (const u of this._uniformTextures){
-            u.finalTexture.dispose();
+    getBlueprintOutput(scope, name) {
+        if (!this._connectedOutputs.has(name)) {
+            return undefined;
+        }
+        return this.getBlueprintOutputMap(scope)[name];
+    }
+    getBlueprintOutputMap(scope) {
+        const pb = scope.$builder;
+        const funcName = 'Z_GetPBRBlueprintOutputs';
+        const that = this;
+        const outputsStruct = pb.defineStruct(DEFAULT_OUTPUT_NAMES.map((name)=>{
+            switch(name){
+                case 'BaseColor':
+                    return pb.vec3(name);
+                case 'Specular':
+                case 'Emissive':
+                case 'Normal':
+                case 'Tangent':
+                    return pb.vec3(name);
+                default:
+                    return pb.float(name);
+            }
+        }));
+        if (!pb.getGlobalScope()[funcName]) {
+            pb.func(funcName, [
+                pb.vec3('worldPos'),
+                pb.vec4('vertexColor'),
+                pb.vec2('vertexUV'),
+                pb.vec3('vertexNormal'),
+                pb.vec3('vertexTangent'),
+                pb.vec3('vertexBinormal')
+            ], function() {
+                this.zWorldPos = this.worldPos;
+                this.zVertexColor = this.vertexColor;
+                this.zVertexUV = this.vertexUV;
+                this.zVertexNormal = this.vertexNormal;
+                this.zVertexTangent = this.vertexTangent;
+                this.zVertexBinormal = this.vertexBinormal;
+                const outputs = that._irFrag.create(pb);
+                let baseColor = pb.vec3(1);
+                let metallic = 0;
+                let roughness = 1;
+                let specular = pb.vec3(1);
+                let emissive = pb.vec3(0);
+                let normal = pb.vec3(0);
+                let tangent = pb.vec3(0);
+                let opacity = 1;
+                let specularWeight = 1;
+                let ao = 1;
+                if (outputs) {
+                    const map = that.toOutputMap(outputs);
+                    if (map.BaseColor !== undefined) {
+                        baseColor = that.toVec3(scope, map.BaseColor);
+                    }
+                    if (map.Metallic !== undefined) {
+                        metallic = map.Metallic;
+                    }
+                    if (map.Roughness !== undefined) {
+                        roughness = map.Roughness;
+                    }
+                    if (map.Specular !== undefined) {
+                        specular = that.toVec3(scope, map.Specular);
+                    }
+                    if (map.Emissive !== undefined) {
+                        emissive = that.toVec3(scope, map.Emissive);
+                    }
+                    if (map.Normal !== undefined) {
+                        normal = that.toVec3(scope, map.Normal);
+                    }
+                    if (map.Tangent !== undefined) {
+                        tangent = that.toVec3(scope, map.Tangent);
+                    }
+                    if (map.Opacity !== undefined) {
+                        opacity = map.Opacity;
+                    }
+                    if (map.SpecularWeight !== undefined) {
+                        specularWeight = map.SpecularWeight;
+                    }
+                    if (map.AO !== undefined) {
+                        ao = map.AO;
+                    }
+                }
+                this.$return(outputsStruct(baseColor, metallic, roughness, specular, emissive, normal, tangent, opacity, specularWeight, ao));
+            });
+        }
+        const result = pb.getGlobalScope()[funcName](this.getBlueprintWorldPos(scope), this.getBlueprintFragmentVertexColor(scope), this.getBlueprintFragmentVertexUV(scope), this.getBlueprintFragmentVertexNormal(scope), this.getBlueprintFragmentVertexTangent(scope), this.getBlueprintFragmentVertexBinormal(scope));
+        const map = {};
+        for (const name of DEFAULT_OUTPUT_NAMES){
+            map[name] = result[name];
+        }
+        return map;
+    }
+    getBlueprintWorldPos(scope) {
+        const pb = scope.$builder;
+        return scope.$inputs.worldPos ?? scope.zWorldPos ?? pb.vec3(0);
+    }
+    getBlueprintFragmentVertexColor(scope) {
+        const pb = scope.$builder;
+        return scope.$inputs.zOutDiffuse ?? scope.zVertexColor ?? pb.vec4(1);
+    }
+    getBlueprintFragmentVertexUV(scope) {
+        const pb = scope.$builder;
+        return scope.$inputs.zVertexUV ?? scope.zVertexUV ?? pb.vec2(0);
+    }
+    getBlueprintFragmentVertexNormal(scope) {
+        const pb = scope.$builder;
+        return scope.$inputs.wNorm ?? scope.zVertexNormal ?? pb.vec3(0, 0, 1);
+    }
+    getBlueprintFragmentVertexTangent(scope) {
+        const pb = scope.$builder;
+        return scope.$inputs.wTangent ?? scope.zVertexTangent ?? pb.vec3(1, 0, 0);
+    }
+    getBlueprintFragmentVertexBinormal(scope) {
+        const pb = scope.$builder;
+        return scope.$inputs.wBinormal ?? scope.zVertexBinormal ?? pb.vec3(0, 1, 0);
+    }
+    toOutputMap(outputs) {
+        const map = {};
+        for (const output of outputs){
+            map[output.name] = output.exp;
         }
+        return map;
     }
-    /**
-   * Retrieves a named output expression from a blueprint output list.
-   *
-   * @param outputs - The list of outputs generated by a blueprint graph.
-   * @param name - The desired output name (e.g. `"Position"`, `"Color"`, `"UV"`).
-   * @returns The expression associated with the given name, or `undefined` if not found.
-   */ getOutput(outputs, name) {
-        return outputs.find((output)=>output.name === name)?.exp;
+    toVertexOutputMap(outputs) {
+        const map = {};
+        for (const output of outputs){
+            map[output.name] = output.exp;
+        }
+        return map;
+    }
+    toFloat(scope, value) {
+        const pb = scope.$builder;
+        if (typeof value === 'number') {
+            return pb.float(value);
+        }
+        const exp = value;
+        return exp.getTypeName() === 'float' ? exp : exp.x;
+    }
+    toVec2(scope, value) {
+        const pb = scope.$builder;
+        if (typeof value === 'number') {
+            return pb.vec2(value);
+        }
+        const exp = value;
+        const type = exp.getTypeName();
+        if (type === 'float') {
+            return pb.vec2(exp);
+        }
+        if (type === 'vec3' || type === 'vec4') {
+            return exp.xy;
+        }
+        return exp;
+    }
+    toVec3(scope, value) {
+        const pb = scope.$builder;
+        if (typeof value === 'number') {
+            return pb.vec3(value);
+        }
+        const exp = value;
+        const type = exp.getTypeName();
+        if (type === 'float') {
+            return pb.vec3(exp);
+        }
+        if (type === 'vec2') {
+            return pb.vec3(exp, 0);
+        }
+        if (type === 'vec4') {
+            return exp.xyz;
+        }
+        return exp;
     }
-    applySubsurfaceScattering(scope, litColor, albedoRGB, normal, viewVec) {
+    toVec4(scope, value, alpha) {
         const pb = scope.$builder;
-        scope.$l.NoV = pb.clamp(pb.dot(normal, viewVec), 0, 1);
-        scope.$l.wrapNdotV = pb.clamp(pb.div(pb.add(pb.sub(1, scope.NoV), scope.zSubsurfaceScale), pb.add(1, scope.zSubsurfaceScale)), 0, 1);
-        scope.$l.sssFactor = pb.mul(pb.pow(scope.wrapNdotV, scope.zSubsurfacePower), scope.zSubsurfaceIntensity);
-        return pb.vec4(pb.add(litColor.rgb, pb.mul(albedoRGB, scope.zSubsurfaceColor, scope.sssFactor)), litColor.a);
+        if (typeof value === 'number') {
+            return pb.vec4(value, value, value, alpha);
+        }
+        const exp = value;
+        const type = exp.getTypeName();
+        if (type === 'float') {
+            return pb.vec4(pb.vec3(exp), alpha);
+        }
+        if (type === 'vec2') {
+            return pb.vec4(exp, 0, alpha);
+        }
+        if (type === 'vec3') {
+            return pb.vec4(exp, alpha);
+        }
+        return exp;
+    }
+    _connectedOutputHash() {
+        return DEFAULT_OUTPUT_NAMES.map((name)=>this._connectedOutputs.has(name) ? '1' : '0').join('');
     }
 }