@zephyr3d/scene 0.9.24 → 0.9.26

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

@@ -1,7 +1,7 @@
 import { PBShaderExp } from '@zephyr3d/device';
 import { ConstantScalarNode, ConstantVec2Node, ConstantVec3Node, ConstantVec4Node, ConstantBooleanNode, ConstantBVec2Node, ConstantBVec3Node, ConstantBVec4Node } from '../common/constants.js';
 import { ASSERT } from '@zephyr3d/base';
-import { BaseTextureNode, TextureSampleNode, PannerNode } from './texture.js';
+import { BaseTextureNode, TextureSampleNode, ChannelSDFMaskNode, MorphBlurNode, PannerNode, TexturePropertyNode } from './texture.js';
 import { MakeVectorNode, SwizzleNode, CompComparisonNode, AnyConditionNode, AllConditionNode, SelectionNode, Hash1Node, Hash2Node, Hash3Node, SimplexNoise2DNode, PerlinNoise2DNode, GenericMathNode, TransformNode, RotateAboutAxisNode } from '../common/math.js';
 import { ResolveVertexPositionNode, ResolveVertexNormalNode, ResolveVertexTangentNode, VertexOutputNode, VertexIndexNode, InstanceIndexNode, VertexColorNode, VertexUVNode, VertexPositionNode, PixelWorldPositionNode, VertexNormalNode, PixelNormalNode, VertexTangentNode, VertexBinormalNode, ViewMatrixNode, ProjectionMatrixNode, ViewProjMatrixNode, InvProjMatrixNode, InvViewProjMatrixNode, BillboardMatrixNode, CameraPositionNode, CameraVectorNode, CameraNearFarNode, SkyEnvTextureNode, ElapsedTimeNode } from './inputs.js';
 import { ShaderHelper } from '../../../material/shader/helper.js';
@@ -100,15 +100,19 @@ import { VertexBlockNode } from './pbr.js';
  */ class IRConstantf extends IRExpression {
     /** The constant float value */ value;
     /** The uniform parameter name, or empty string for literals */ name;
+    /** Optional lower bound for editor-facing scalar parameters */ minValue;
+    /** Optional upper bound for editor-facing scalar parameters */ maxValue;
     /**
    * Creates a constant float expression
    *
    * @param value - The float value
    * @param paramName - The uniform parameter name, or empty string for literals
-   */ constructor(value, paramName){
+   */ constructor(value, paramName, minValue, maxValue){
         super();
         this.value = value;
         this.name = paramName;
+        this.minValue = minValue;
+        this.maxValue = maxValue;
     }
     /**
    * Generates shader code for this constant
@@ -139,7 +143,13 @@ import { VertexBlockNode } from './pbr.js';
             value: [
                 this.value
             ],
-            type: 'float'
+            type: 'float',
+            ...this.minValue !== undefined ? {
+                minValue: this.minValue
+            } : {},
+            ...this.maxValue !== undefined ? {
+                maxValue: this.maxValue
+            } : {}
         } : null;
     }
 }
@@ -418,6 +428,7 @@ import { VertexBlockNode } from './pbr.js';
     /** The function call node from the graph */ node;
     /** Array of argument expressions */ args;
     /** Cached temporary variable name if result is referenced multiple times */ tmpName;
+    textureArgSamplerNames;
     /**
    * Creates a function call expression
    *
@@ -428,9 +439,58 @@ import { VertexBlockNode } from './pbr.js';
         this.node = node;
         this.args = args;
         this.tmpName = '';
+        this.textureArgSamplerNames = new Map();
     }
     /** Reset for next creation */ reset() {
         this.tmpName = '';
+        this.textureArgSamplerNames.clear();
+    }
+    getTextureSamplerVarName(argName) {
+        let name = this.textureArgSamplerNames.get(argName);
+        if (!name) {
+            name = `${argName}__sampler`;
+            this.textureArgSamplerNames.set(argName, name);
+        }
+        return name;
+    }
+    buildTextureFunctionParams(pb) {
+        const params = [];
+        for (const arg of this.node.args){
+            // @ts-ignore
+            params.push(pb[arg.type](arg.name));
+            if (arg.type === 'tex2D' && pb.getDevice().type === 'webgpu') {
+                params.push(pb.sampler(this.getTextureSamplerVarName(arg.name)));
+            }
+        }
+        return params;
+    }
+    buildTextureFunctionCallArgs(pb) {
+        const args = [];
+        for(let i = 0; i < this.node.args.length; i++){
+            const argDef = this.node.args[i];
+            const argExp = this.args[i].create(pb);
+            args.push(argExp);
+            if (argDef.type === 'tex2D' && pb.getDevice().type === 'webgpu') {
+                if (!(argExp instanceof PBShaderExp)) {
+                    throw new Error(`Material function '${this.node.name}' expects texture argument '${argDef.name}'`);
+                }
+                let sampler = pb.getDefaultSampler(argExp, false);
+                if (!sampler && argExp.$str) {
+                    sampler = pb.getCurrentScope()[this.getTextureSamplerVarName(argExp.$str)];
+                }
+                if (!sampler) {
+                    throw new Error(`Material function '${this.node.name}' cannot resolve sampler for texture argument '${argDef.name}'`);
+                }
+                args.push(sampler);
+            }
+        }
+        return args;
+    }
+    isSingleTextureOutput() {
+        return this.node.outs.length === 1 && this.node.outs[0].type === 'tex2D';
+    }
+    hasTextureOutput() {
+        return this.node.outs.some((output)=>output.type === 'tex2D');
     }
     /**
    * Generates shader code for the function definition and call
@@ -446,21 +506,34 @@ import { VertexBlockNode } from './pbr.js';
         if (this.tmpName) {
             return pb.getCurrentScope()[this.tmpName];
         }
+        if (this.hasTextureOutput() && !this.isSingleTextureOutput()) {
+            throw new Error(`Material function '${this.node.name}' only supports tex2D as a single standalone output`);
+        }
         const that = this;
         const ir = this.node.IR;
-        // @ts-ignore
-        const params = this.node.args.map((v)=>pb[v.type](v.name));
+        const params = this.buildTextureFunctionParams(pb);
         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)=>{
-                return output.exp;
-            })));
+            const orderedOutputs = that.node.outs.map((output)=>{
+                const index = ir.DAG.roots.indexOf(output.index);
+                if (index < 0 || !outputs[index]) {
+                    throw new Error(`Material function '${that.node.name}' cannot resolve output '${output.name}'`);
+                }
+                return outputs[index];
+            });
+            if (that.isSingleTextureOutput()) {
+                this.$return(orderedOutputs[0].exp);
+            } else {
+                const rettype = pb.defineStruct(that.node.outputs.map((output, index)=>{
+                    // @ts-ignore
+                    return pb[that.node.outs[index].type](output.swizzle);
+                }));
+                this.$return(rettype(...orderedOutputs.map((output)=>{
+                    return output.exp;
+                })));
+            }
         });
-        const args = this.args.map((arg)=>arg.create(pb));
+        const args = this.buildTextureFunctionCallArgs(pb);
         const exp = pb.getGlobalScope()[this.node.name](...args);
         if (this._ref === 1) {
             return exp;
@@ -779,7 +852,21 @@ class IRComparison extends IRExpression {
         } else {
             throw new Error('Invalid texture coordinate');
         }
-        let exp = pb.textureSample(texExp, coordExp);
+        let exp;
+        if (pb.getDevice().type === 'webgpu') {
+            let sampler = pb.getDefaultSampler(texExp, false);
+            if (!sampler && texExp.$str) {
+                sampler = pb.getCurrentScope()[`${texExp.$str}__sampler`];
+            }
+            if (sampler) {
+                // @ts-ignore ProgramBuilder runtime supports the explicit WebGPU sampler overload.
+                exp = pb.textureSample(texExp, sampler, coordExp);
+            } else {
+                exp = pb.textureSample(texExp, coordExp);
+            }
+        } else {
+            exp = pb.textureSample(texExp, coordExp);
+        }
         if (this.samplerType === 'Normal') {
             exp = pb.sub(pb.mul(exp, pb.vec4(2, 2, 2, 1)), pb.vec4(1, 1, 1, 0));
         }
@@ -792,6 +879,284 @@ class IRComparison extends IRExpression {
         }
     }
 }
+class IRMorphBlur extends IRExpression {
+    tex;
+    coord;
+    morphRadius;
+    blurRadius;
+    channelMask;
+    tmpName;
+    constructor(tex, coord, morphRadius, blurRadius, channelMask){
+        super();
+        this.tex = tex.addRef();
+        this.coord = coord.addRef();
+        this.morphRadius = morphRadius instanceof IRExpression ? morphRadius.addRef() : morphRadius;
+        this.blurRadius = blurRadius instanceof IRExpression ? blurRadius.addRef() : blurRadius;
+        this.channelMask = channelMask instanceof IRExpression ? channelMask.addRef() : channelMask.slice();
+        this.tmpName = '';
+    }
+    reset() {
+        this.tmpName = '';
+    }
+    create(pb) {
+        if (this.tmpName) {
+            return pb.getCurrentScope()[this.tmpName];
+        }
+        const texExp = this.tex.create(pb);
+        const coordExp = this.coord.create(pb);
+        const morphExp = this.morphRadius instanceof IRExpression ? this.morphRadius.create(pb) : this.morphRadius;
+        const blurExp = this.blurRadius instanceof IRExpression ? this.blurRadius.create(pb) : this.blurRadius;
+        const maskExpRaw = this.channelMask instanceof IRExpression ? this.channelMask.create(pb) : pb.vec4(this.channelMask[0] ?? 0, this.channelMask[1] ?? 0, this.channelMask[2] ?? 0, this.channelMask[3] ?? 0);
+        if (!(texExp instanceof PBShaderExp) || !(coordExp instanceof PBShaderExp) || !(maskExpRaw instanceof PBShaderExp)) {
+            throw new Error('Invalid texture sampling input');
+        }
+        const maskExp = maskExpRaw;
+        const texVarName = texExp.$str || 'Texture';
+        const funcName = `Z_MorphBlur_${texVarName.replace(/[^A-Za-z0-9_]/g, '_')}`;
+        const sampleMaskedName = `${funcName}_sampleMasked`;
+        const morphValueName = `${funcName}_morphValue`;
+        const blurBaseName = `${funcName}_blurBase`;
+        const texelSize = pb.div(pb.vec2(1), pb.vec2(pb.textureDimensions(texExp, 0)));
+        pb.func(sampleMaskedName, [
+            pb.tex2D('texture'),
+            ...pb.getDevice().type === 'webgpu' ? [
+                pb.sampler('texture__sampler')
+            ] : [],
+            pb.vec2('uv'),
+            pb.vec4('channelMask')
+        ], function() {
+            this.$l.sampled = pb.getDevice().type === 'webgpu' ? pb.textureSample(this.texture, this.texture__sampler, this.uv) : pb.textureSample(this.texture, this.uv);
+            this.$return(pb.dot(this.sampled, this.channelMask));
+        });
+        pb.func(morphValueName, [
+            pb.tex2D('texture'),
+            ...pb.getDevice().type === 'webgpu' ? [
+                pb.sampler('texture__sampler')
+            ] : [],
+            pb.vec2('uv'),
+            pb.vec2('texelSize'),
+            pb.float('morphRadius'),
+            pb.vec4('channelMask')
+        ], function() {
+            this.$l.morphStep = pb.abs(this.morphRadius);
+            this.$l.morphOffsets = pb.vec2[5]();
+            this.morphOffsets.setAt(0, pb.vec2(0, 0));
+            this.morphOffsets.setAt(1, pb.vec2(this.morphStep, 0));
+            this.morphOffsets.setAt(2, pb.vec2(pb.neg(this.morphStep), 0));
+            this.morphOffsets.setAt(3, pb.vec2(0, this.morphStep));
+            this.morphOffsets.setAt(4, pb.vec2(0, pb.neg(this.morphStep)));
+            this.$if(pb.greaterThan(this.morphRadius, 0), function() {
+                this.$l.dilateValue = pb.float(0);
+                this.$for(pb.int('morphIndex'), 0, 5, function() {
+                    this.$l.sampleUV = pb.add(this.uv, pb.mul(this.morphOffsets.at(this.morphIndex), this.texelSize));
+                    this.$l.sampleValue = pb.getDevice().type === 'webgpu' ? this[sampleMaskedName](this.texture, this.texture__sampler, this.sampleUV, this.channelMask) : this[sampleMaskedName](this.texture, this.sampleUV, this.channelMask);
+                    this.$if(pb.equal(this.morphIndex, 0), function() {
+                        this.dilateValue = this.sampleValue;
+                    }).$else(function() {
+                        this.dilateValue = pb.max(this.dilateValue, this.sampleValue);
+                    });
+                });
+                this.$return(this.dilateValue);
+            }).$elseif(pb.lessThan(this.morphRadius, 0), function() {
+                this.$l.erodeValue = pb.float(0);
+                this.$for(pb.int('morphIndex'), 0, 5, function() {
+                    this.$l.sampleUV = pb.add(this.uv, pb.mul(this.morphOffsets.at(this.morphIndex), this.texelSize));
+                    this.$l.sampleValue = pb.getDevice().type === 'webgpu' ? this[sampleMaskedName](this.texture, this.texture__sampler, this.sampleUV, this.channelMask) : this[sampleMaskedName](this.texture, this.sampleUV, this.channelMask);
+                    this.$if(pb.equal(this.morphIndex, 0), function() {
+                        this.erodeValue = this.sampleValue;
+                    }).$else(function() {
+                        this.erodeValue = pb.min(this.erodeValue, this.sampleValue);
+                    });
+                });
+                this.$return(this.erodeValue);
+            }).$else(function() {
+                this.$return(pb.getDevice().type === 'webgpu' ? this[sampleMaskedName](this.texture, this.texture__sampler, this.uv, this.channelMask) : this[sampleMaskedName](this.texture, this.uv, this.channelMask));
+            });
+        });
+        pb.func(blurBaseName, [
+            pb.tex2D('texture'),
+            ...pb.getDevice().type === 'webgpu' ? [
+                pb.sampler('texture__sampler')
+            ] : [],
+            pb.vec2('uv'),
+            pb.vec2('texelSize'),
+            pb.float('blurRadius'),
+            pb.vec4('channelMask'),
+            pb.float('morphRadius'),
+            pb.bool('useMorph')
+        ], function() {
+            this.$l.radius = pb.max(this.blurRadius, 0);
+            this.$l.sigma = pb.max(pb.mul(this.radius, 0.6), 0.85);
+            this.$l.invSigma2 = pb.div(0.5, pb.mul(this.sigma, this.sigma));
+            this.$l.kernelRadius = pb.int(2);
+            this.$if(pb.greaterThan(this.radius, 1.5), function() {
+                this.kernelRadius = pb.int(3);
+            });
+            this.$if(pb.greaterThan(this.radius, 3), function() {
+                this.kernelRadius = pb.int(4);
+            });
+            this.$if(pb.greaterThan(this.radius, 5), function() {
+                this.kernelRadius = pb.int(5);
+            });
+            this.$if(pb.greaterThan(this.radius, 7.5), function() {
+                this.kernelRadius = pb.int(6);
+            });
+            this.$if(pb.greaterThan(this.radius, 9), function() {
+                this.kernelRadius = pb.int(7);
+            });
+            this.$if(pb.greaterThan(this.radius, 10.5), function() {
+                this.kernelRadius = pb.int(8);
+            });
+            this.$if(pb.greaterThan(this.radius, 12), function() {
+                this.kernelRadius = pb.int(9);
+            });
+            this.$if(pb.greaterThan(this.radius, 13.5), function() {
+                this.kernelRadius = pb.int(10);
+            });
+            this.$if(pb.greaterThan(this.radius, 15), function() {
+                this.kernelRadius = pb.int(11);
+            });
+            this.$if(pb.greaterThan(this.radius, 16.5), function() {
+                this.kernelRadius = pb.int(12);
+            });
+            this.$l.kernelRadiusF = pb.max(pb.float(this.kernelRadius), 1);
+            this.$l.sampleStep = pb.max(pb.div(this.radius, this.kernelRadiusF), 1);
+            this.$l.supportRadius = pb.max(this.radius, 1);
+            this.$l.supportRadius2 = pb.mul(this.supportRadius, this.supportRadius);
+            this.$l.sum = pb.float(0);
+            this.$l.weightSum = pb.float(0);
+            this.$for(pb.int('blurY'), 0, 25, function() {
+                this.$l.offsetY = pb.sub(this.blurY, 12);
+                this.$if(pb.lessThanEqual(pb.abs(this.offsetY), this.kernelRadius), function() {
+                    this.$for(pb.int('blurX'), 0, 25, function() {
+                        this.$l.offsetX = pb.sub(this.blurX, 12);
+                        this.$if(pb.lessThanEqual(pb.abs(this.offsetX), this.kernelRadius), function() {
+                            this.$l.sampleOffset = pb.mul(pb.vec2(pb.float(this.offsetX), pb.float(this.offsetY)), this.sampleStep);
+                            this.$l.sampleRadius2 = pb.dot(this.sampleOffset, this.sampleOffset);
+                            this.$if(pb.lessThanEqual(this.sampleRadius2, this.supportRadius2), function() {
+                                this.$l.sampleUV = pb.add(this.uv, pb.mul(this.sampleOffset, this.texelSize));
+                                this.$l.sampleValue = this.useMorph ? pb.getDevice().type === 'webgpu' ? this[morphValueName](this.texture, this.texture__sampler, this.sampleUV, this.texelSize, this.morphRadius, this.channelMask) : this[morphValueName](this.texture, this.sampleUV, this.texelSize, this.morphRadius, this.channelMask) : pb.getDevice().type === 'webgpu' ? this[sampleMaskedName](this.texture, this.texture__sampler, this.sampleUV, this.channelMask) : this[sampleMaskedName](this.texture, this.sampleUV, this.channelMask);
+                                this.$l.weight = pb.exp(pb.neg(pb.mul(this.sampleRadius2, this.invSigma2)));
+                                this.sum = pb.add(this.sum, pb.mul(this.sampleValue, this.weight));
+                                this.weightSum = pb.add(this.weightSum, this.weight);
+                            });
+                        });
+                    });
+                });
+            });
+            this.$return(pb.div(this.sum, pb.max(this.weightSum, 1e-5)));
+        });
+        pb.func(funcName, [
+            pb.tex2D('texture'),
+            ...pb.getDevice().type === 'webgpu' ? [
+                pb.sampler('texture__sampler')
+            ] : [],
+            pb.vec2('uv'),
+            pb.vec2('texelSize'),
+            pb.float('morphRadius'),
+            pb.float('blurRadius'),
+            pb.vec4('channelMask')
+        ], function() {
+            this.$l.morphAbs = pb.abs(this.morphRadius);
+            this.$l.blurAbs = pb.abs(this.blurRadius);
+            this.$if(pb.lessThanEqual(this.morphAbs, 1e-4), function() {
+                this.$if(pb.lessThanEqual(this.blurAbs, 1e-4), function() {
+                    this.$return(pb.getDevice().type === 'webgpu' ? this[sampleMaskedName](this.texture, this.texture__sampler, this.uv, this.channelMask) : this[sampleMaskedName](this.texture, this.uv, this.channelMask));
+                }).$else(function() {
+                    this.$return(pb.getDevice().type === 'webgpu' ? this[blurBaseName](this.texture, this.texture__sampler, this.uv, this.texelSize, this.blurRadius, this.channelMask, this.morphRadius, false) : this[blurBaseName](this.texture, this.uv, this.texelSize, this.blurRadius, this.channelMask, this.morphRadius, false));
+                });
+            }).$elseif(pb.lessThanEqual(this.blurAbs, 1e-4), function() {
+                this.$return(pb.getDevice().type === 'webgpu' ? this[morphValueName](this.texture, this.texture__sampler, this.uv, this.texelSize, this.morphRadius, this.channelMask) : this[morphValueName](this.texture, this.uv, this.texelSize, this.morphRadius, this.channelMask));
+            }).$else(function() {
+                this.$return(pb.getDevice().type === 'webgpu' ? this[blurBaseName](this.texture, this.texture__sampler, this.uv, this.texelSize, this.blurRadius, this.channelMask, this.morphRadius, true) : this[blurBaseName](this.texture, this.uv, this.texelSize, this.blurRadius, this.channelMask, this.morphRadius, true));
+            });
+        });
+        const callArgs = [
+            texExp,
+            ...pb.getDevice().type === 'webgpu' ? [
+                pb.getDefaultSampler(texExp, false) ?? pb.getCurrentScope()[`${texExp.$str}__sampler`]
+            ] : [],
+            coordExp,
+            texelSize,
+            morphExp,
+            blurExp,
+            maskExp
+        ];
+        if (pb.getDevice().type === 'webgpu' && !(callArgs[1] instanceof PBShaderExp)) {
+            throw new Error('Cannot resolve sampler for MorphBlur node');
+        }
+        const exp = pb.getGlobalScope()[funcName](...callArgs);
+        if (this._ref === 1) {
+            return exp;
+        }
+        this.tmpName = this.getTmpName(pb.getCurrentScope());
+        pb.getCurrentScope()[this.tmpName] = exp;
+        return pb.getCurrentScope()[this.tmpName];
+    }
+}
+class IRChannelSDFMask extends IRExpression {
+    tex;
+    coord;
+    sizeOffset;
+    feather;
+    spread;
+    edgeCurve;
+    channelMask;
+    tmpName;
+    constructor(tex, coord, sizeOffset, feather, spread, edgeCurve, channelMask){
+        super();
+        this.tex = tex.addRef();
+        this.coord = coord.addRef();
+        this.sizeOffset = sizeOffset instanceof IRExpression ? sizeOffset.addRef() : sizeOffset;
+        this.feather = feather instanceof IRExpression ? feather.addRef() : feather;
+        this.spread = spread instanceof IRExpression ? spread.addRef() : spread;
+        this.edgeCurve = edgeCurve instanceof IRExpression ? edgeCurve.addRef() : edgeCurve;
+        this.channelMask = channelMask instanceof IRExpression ? channelMask.addRef() : channelMask.slice();
+        this.tmpName = '';
+    }
+    reset() {
+        this.tmpName = '';
+    }
+    create(pb) {
+        if (this.tmpName) {
+            return pb.getCurrentScope()[this.tmpName];
+        }
+        const texExp = this.tex.create(pb);
+        const coordExp = this.coord.create(pb);
+        const sizeExp = this.sizeOffset instanceof IRExpression ? this.sizeOffset.create(pb) : this.sizeOffset;
+        const featherExp = this.feather instanceof IRExpression ? this.feather.create(pb) : this.feather;
+        const spreadExp = this.spread instanceof IRExpression ? this.spread.create(pb) : this.spread;
+        const edgeCurveExp = this.edgeCurve instanceof IRExpression ? this.edgeCurve.create(pb) : this.edgeCurve;
+        const maskExpRaw = this.channelMask instanceof IRExpression ? this.channelMask.create(pb) : pb.vec4(this.channelMask[0] ?? 0, this.channelMask[1] ?? 0, this.channelMask[2] ?? 0, this.channelMask[3] ?? 0);
+        if (!(texExp instanceof PBShaderExp) || !(coordExp instanceof PBShaderExp) || !(maskExpRaw instanceof PBShaderExp)) {
+            throw new Error('Invalid texture sampling input');
+        }
+        const maskExp = maskExpRaw;
+        const sampled = pb.dot(pb.textureSample(texExp, coordExp), maskExp);
+        const spreadSafe = pb.max(pb.abs(spreadExp), 1e-5);
+        const featherSafe = pb.max(pb.abs(featherExp), 1e-5);
+        const edgeCurveSafe = pb.max(edgeCurveExp, 1e-5);
+        const signedDistance = pb.mul(pb.sub(sampled, 0.5), pb.mul(spreadSafe, 2));
+        const linearMask = pb.clamp(pb.add(pb.div(pb.add(signedDistance, sizeExp), pb.mul(featherSafe, 2)), 0.5), 0, 1);
+        const linearMask2 = pb.mul(linearMask, linearMask);
+        const linearMask3 = pb.mul(linearMask2, linearMask);
+        const smootherMask = pb.mul(linearMask3, pb.add(pb.mul(linearMask, pb.sub(pb.mul(linearMask, 6), 15)), 10));
+        const softAmount = pb.clamp(pb.sub(1, pb.div(1, edgeCurveSafe)), 0, 1);
+        const softenedMask = pb.mix(linearMask, smootherMask, softAmount);
+        const sharpPower = pb.div(1, edgeCurveSafe);
+        const belowSharp = pb.mul(0.5, pb.pow(pb.mul(linearMask, 2), sharpPower));
+        const aboveSharp = pb.sub(1, pb.mul(0.5, pb.pow(pb.mul(pb.sub(1, linearMask), 2), sharpPower)));
+        const sharpMask = pb.select(aboveSharp, belowSharp, pb.lessThan(linearMask, 0.5));
+        const sharpAmount = pb.clamp(pb.sub(1, edgeCurveSafe), 0, 1);
+        const exp = pb.mix(softenedMask, sharpMask, sharpAmount);
+        if (this._ref === 1) {
+            return exp;
+        }
+        this.tmpName = this.getTmpName(pb.getCurrentScope());
+        pb.getCurrentScope()[this.tmpName] = exp;
+        return pb.getCurrentScope()[this.tmpName];
+    }
+}
 /**
  * IR expression for texture uniform constants
  *
@@ -823,6 +1188,7 @@ class IRComparison extends IRExpression {
     /** Minification filter mode */ filterMin;
     /** Magnification filter mode */ filterMag;
     /** Mipmap filter mode */ filterMip;
+    /** Whether this texture parameter should be exposed to material instances */ exposed;
     /** Whether texture params is used */ useParams;
     /**
    * Creates a texture constant expression
@@ -836,7 +1202,7 @@ class IRComparison extends IRExpression {
    * @param minFilter - Minification filter
    * @param magFilter - Magnification filter
    * @param mipFilter - Mipmap filter
-   */ constructor(name, id, type, sRGB, addressU, addressV, minFilter, magFilter, mipFilter){
+   */ constructor(name, id, type, sRGB, addressU, addressV, minFilter, magFilter, mipFilter, exposed = true){
         super();
         this.name = name;
         this.id = id;
@@ -847,6 +1213,7 @@ class IRComparison extends IRExpression {
         this.filterMin = minFilter;
         this.filterMag = magFilter;
         this.filterMip = mipFilter;
+        this.exposed = exposed;
         this.useParams = false;
     }
     /**
@@ -860,7 +1227,14 @@ class IRComparison extends IRExpression {
    */ create(pb) {
         if (!pb.getGlobalScope()[this.name]) {
             // @ts-ignore
-            pb.getGlobalScope()[this.name] = pb[this.type]().uniform(2);
+            const exp = pb[this.type]().uniform(2).withSampler({
+                addressU: this.addressU,
+                addressV: this.addressV,
+                minFilter: this.filterMin,
+                magFilter: this.filterMag,
+                mipFilter: this.filterMip
+            });
+            pb.getGlobalScope()[this.name] = exp;
         }
         return pb.getGlobalScope()[this.name];
     }
@@ -873,6 +1247,7 @@ class IRComparison extends IRExpression {
         return {
             name: this.name,
             texture: this.id,
+            exposed: this.exposed,
             wrapS: this.addressU,
             wrapT: this.addressV,
             minFilter: this.filterMin,
@@ -910,6 +1285,7 @@ class IRComparison extends IRExpression {
     /** Array of uniform scalar/vector values to be set at runtime */ _uniformValues;
     /** Array of uniform textures to be bound at runtime */ _uniformTextures;
     /** Fallback texture uniforms generated for TextureSample nodes without texture input */ _textureSampleFallbackMap;
+    /** Shared fallback texture uniforms keyed by texture identity and sampling config */ _sharedTextureUniformMap;
     /** Flags indicating which shader features are used */ _behaviors;
     /** Array of named output expressions (e.g., baseColor, normal, metallic) */ _outputs;
     /**
@@ -1060,12 +1436,41 @@ class IRComparison extends IRExpression {
         this._uniformTextures = [];
         this._uniformValues = [];
         this._textureSampleFallbackMap = new Map();
+        this._sharedTextureUniformMap = new Map();
         this._outputs = null;
         this._behaviors = {
             useVertexColor: false,
             useVertexUV: false
         };
     }
+    /** Builds a stable key for reusing identical blueprint texture uniforms */ getSharedTextureUniformKey(name, textureId, type, exposed, sRGB, addressU, addressV, filterMin, filterMag, filterMip) {
+        return [
+            name,
+            type,
+            textureId || '__default__',
+            exposed ? 'exposed' : 'hidden',
+            sRGB ? 'srgb' : 'linear',
+            addressU,
+            addressV,
+            filterMin,
+            filterMag,
+            filterMip
+        ].join('|');
+    }
+    /** Gets or creates a shared texture uniform for identical fallback texture sample nodes */ getOrCreateSharedTextureUniform(name, textureId, type, exposed, sRGB, addressU, addressV, filterMin, filterMag, filterMip) {
+        const key = this.getSharedTextureUniformKey(name, textureId, type, exposed, sRGB, addressU, addressV, filterMin, filterMag, filterMip);
+        let ir = this._sharedTextureUniformMap.get(key);
+        if (!ir) {
+            ir = new IRConstantTexture(name, textureId, type, sRGB, addressU, addressV, filterMin, filterMag, filterMip, exposed);
+            this._sharedTextureUniformMap.set(key, ir);
+            this._expressions.push(ir);
+            const uniformTexture = ir.asUniformTexture();
+            if (uniformTexture) {
+                this._uniformTextures.push(uniformTexture);
+            }
+        }
+        return ir;
+    }
     /**
    * Converts a graph node to an IR expression
    *
@@ -1097,6 +1502,10 @@ class IRComparison extends IRExpression {
             expr = this.constantTexture(node, output);
         } else if (node instanceof TextureSampleNode) {
             expr = this.textureSample(node, output);
+        } else if (node instanceof ChannelSDFMaskNode) {
+            expr = this.channelSDFMask(node, output);
+        } else if (node instanceof MorphBlurNode) {
+            expr = this.morphBlur(node, output);
         } else if (node instanceof PannerNode) {
             expr = this.panner(node, output);
         } else if (node instanceof MakeVectorNode) {
@@ -1183,6 +1592,8 @@ class IRComparison extends IRExpression {
             expr = this.functionInput(node, output);
         } else if (node instanceof FunctionOutputNode) {
             expr = this.functionOutput(node, output);
+        } else if (node instanceof TexturePropertyNode) {
+            expr = this.textureProperty(node, output);
         }
         if (expr && originType) {
             const outputType = node.getOutputType(output);
@@ -1611,7 +2022,7 @@ class IRComparison extends IRExpression {
         return this.getOrCreateIRExpression(node, output, IRCallFunc, node, args);
     }
     /** Converts a scalar constant node to IR */ constantf(node, output) {
-        return this.getOrCreateIRExpression(node, output, IRConstantf, node.x, node.paramName);
+        return this.getOrCreateIRExpression(node, output, IRConstantf, node.x, node.isUniform ? node.paramName : '', node.isUniform && node.useRange ? node.minValue : undefined, node.isUniform && node.useRange ? node.maxValue : undefined);
     }
     /** Converts a vector constant node to IR */ constantfv(node, output) {
         const value = node instanceof ConstantVec2Node ? [
@@ -1627,7 +2038,7 @@ class IRComparison extends IRExpression {
             node.z,
             node.w
         ];
-        return this.getOrCreateIRExpression(node, output, IRConstantfv, value, node.paramName, `vec${value.length}`);
+        return this.getOrCreateIRExpression(node, output, IRConstantfv, value, node.isUniform ? node.paramName : '', `vec${value.length}`);
     }
     /** Converts a scalar boolean constant node to IR */ constantb(node, output) {
         return this.getOrCreateIRExpression(node, output, IRConstantb, node.x);
@@ -1649,7 +2060,19 @@ class IRComparison extends IRExpression {
         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);
+        return this.getOrCreateIRExpression(node, output, class SharedIRConstantTextureProxy extends IRExpression {
+            _shared;
+            constructor(shared){
+                super();
+                this._shared = shared;
+            }
+            create(pb) {
+                return this._shared.create(pb);
+            }
+            asUniformTexture() {
+                return null;
+            }
+        }, this.getOrCreateSharedTextureUniform(node.paramName, node.textureId, node.getOutputType(1), node.expose, node.sRGB, node.addressU, node.addressV, node.filterMin, node.filterMag, node.filterMip));
     }
     /** Converts a texture sample node to IR */ textureSample(node, output) {
         const tex = node.inputs[0].inputNode ? this.ir(node.inputs[0]) : this.textureSampleFallbackTexture(node);
@@ -1659,16 +2082,58 @@ class IRComparison extends IRExpression {
         })();
         return this.getOrCreateIRExpression(node, output, IRSampleTexture, tex, coord, node.samplerType);
     }
+    /** Converts a texture property node to IR */ textureProperty(node, output) {
+        const tex = this.ir(node.inputs[0]);
+        const func = node.property === 'TextureSize' ? (pb, ...params)=>{
+            const texture = params[0];
+            return pb.vec2(pb.textureDimensions(texture, 0));
+        } : (pb, ...params)=>{
+            const texture = params[0];
+            return pb.div(pb.vec2(1), pb.vec2(pb.textureDimensions(texture, 0)));
+        };
+        return this.getOrCreateIRExpression(node, output, IRFunc, [
+            tex
+        ], func);
+    }
+    channelSDFMask(node, output) {
+        const tex = node.inputs[0].inputNode ? this.ir(node.inputs[0]) : this.getOrCreateSharedTextureUniform(node.paramName, node.textureId, 'tex2D', node.expose, node.sRGB, node.addressU, node.addressV, node.filterMin, node.filterMag, node.filterMip);
+        const coord = node.inputs[1].inputNode ? this.ir(node.inputs[1]) : (()=>{
+            this._behaviors.useVertexUV = true;
+            return new IRInput((scope)=>scope.zVertexUV);
+        })();
+        const sizeOffset = node.inputs[2].inputNode ? this.ir(node.inputs[2]) : node.inputs[2].defaultValue?.[0] ?? 0;
+        const feather = node.inputs[3].inputNode ? this.ir(node.inputs[3]) : node.inputs[3].defaultValue?.[0] ?? 0;
+        const spread = node.inputs[4].inputNode ? this.ir(node.inputs[4]) : node.inputs[4].defaultValue?.[0] ?? 16;
+        const edgeCurve = node.inputs[5].inputNode ? this.ir(node.inputs[5]) : node.inputs[5].defaultValue?.[0] ?? 1;
+        const channelMask = node.inputs[6].inputNode ? this.ir(node.inputs[6]) : node.inputs[6].defaultValue ?? [
+            1,
+            0,
+            0,
+            0
+        ];
+        return this.getOrCreateIRExpression(node, output, IRChannelSDFMask, tex, coord, sizeOffset, feather, spread, edgeCurve, channelMask);
+    }
+    morphBlur(node, output) {
+        const tex = node.inputs[0].inputNode ? this.ir(node.inputs[0]) : this.getOrCreateSharedTextureUniform(node.paramName, node.textureId, 'tex2D', node.expose, node.sRGB, node.addressU, node.addressV, node.filterMin, node.filterMag, node.filterMip);
+        const coord = node.inputs[1].inputNode ? this.ir(node.inputs[1]) : (()=>{
+            this._behaviors.useVertexUV = true;
+            return new IRInput((scope)=>scope.zVertexUV);
+        })();
+        const morphRadius = node.inputs[2].inputNode ? this.ir(node.inputs[2]) : node.inputs[2].defaultValue?.[0] ?? 0;
+        const blurRadius = node.inputs[3].inputNode ? this.ir(node.inputs[3]) : node.inputs[3].defaultValue?.[0] ?? 0;
+        const channelMask = node.inputs[4].inputNode ? this.ir(node.inputs[4]) : node.inputs[4].defaultValue ?? [
+            1,
+            0,
+            0,
+            0
+        ];
+        return this.getOrCreateIRExpression(node, output, IRMorphBlur, tex, coord, morphRadius, blurRadius, channelMask);
+    }
     /** Gets or creates fallback texture uniform expression for texture sample nodes */ textureSampleFallbackTexture(node) {
         let ir = this._textureSampleFallbackMap.get(node);
         if (!ir) {
-            ir = new IRConstantTexture(node.paramName, node.textureId, 'tex2D', node.sRGB, node.addressU, node.addressV, node.filterMin, node.filterMag, node.filterMip);
-            this._expressions.push(ir);
+            ir = this.getOrCreateSharedTextureUniform(node.paramName, node.textureId, 'tex2D', node.expose, node.sRGB, node.addressU, node.addressV, node.filterMin, node.filterMag, node.filterMip);
             this._textureSampleFallbackMap.set(node, ir);
-            const uniformTexture = ir.asUniformTexture();
-            if (uniformTexture) {
-                this._uniformTextures.push(uniformTexture);
-            }
         }
         return ir;
     }