@zephyr3d/scene 0.8.2 → 0.9.0

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

@@ -1,9 +1,9 @@
 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 } from './texture.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 { BaseTextureNode, TextureSampleNode, PannerNode } 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, 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';
 import { FunctionCallNode, FunctionInputNode, FunctionOutputNode } from './func.js';
 import { hash11, hash21, hash31, hash12, hash22, hash32, hash13, hash23, hash33, valueNoise } from '../../../shaders/noise.js';
@@ -330,8 +330,11 @@ import { VertexBlockNode } from './pbr.js';
    */ create(pb) {
         if (this.tmpName) {
             const exp = pb.getCurrentScope()[this.tmpName];
-            ASSERT(!!exp, 'expression not exists');
-            return exp;
+            if (exp) {
+                return exp;
+            }
+            // Scope changed, recompute in current scope
+            this.tmpName = '';
         }
         const params = this.params.map((param)=>param instanceof IRExpression ? param.create(pb) : param);
         // @ts-ignore
@@ -723,7 +726,7 @@ class IRComparison extends IRExpression {
  *
  * @public
  */ class IRSampleTexture extends IRExpression {
-    /** The texture constant expression */ tex;
+    /** The texture expression */ tex;
     /** The texture coordinate expression */ coord;
     /** The sampler type determining how to interpret the sampled value */ samplerType;
     /** Cached temporary variable name if result is referenced multiple times */ tmpName;
@@ -762,6 +765,12 @@ class IRComparison extends IRExpression {
         const tex = this.tex.create(pb);
         const coord = this.coord.create(pb);
         let coordExp;
+        let texExp;
+        if (tex instanceof PBShaderExp) {
+            texExp = tex;
+        } else {
+            throw new Error('Invalid texture expression');
+        }
         if (coord instanceof PBShaderExp) {
             coordExp = coord;
         } else if (Array.isArray(coord)) {
@@ -770,7 +779,7 @@ class IRComparison extends IRExpression {
         } else {
             throw new Error('Invalid texture coordinate');
         }
-        let exp = pb.textureSample(tex, coordExp);
+        let 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));
         }
@@ -900,6 +909,7 @@ class IRComparison extends IRExpression {
     /** Map from graph node to IR expression index */ _expressionMap;
     /** 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;
     /** Flags indicating which shader features are used */ _behaviors;
     /** Array of named output expressions (e.g., baseColor, normal, metallic) */ _outputs;
     /**
@@ -1049,6 +1059,7 @@ class IRComparison extends IRExpression {
         this._expressionMap = new Map();
         this._uniformTextures = [];
         this._uniformValues = [];
+        this._textureSampleFallbackMap = new Map();
         this._outputs = null;
         this._behaviors = {
             useVertexColor: false,
@@ -1086,6 +1097,8 @@ class IRComparison extends IRExpression {
             expr = this.constantTexture(node, output);
         } else if (node instanceof TextureSampleNode) {
             expr = this.textureSample(node, output);
+        } else if (node instanceof PannerNode) {
+            expr = this.panner(node, output);
         } else if (node instanceof MakeVectorNode) {
             expr = this.makeVector(node, output);
         } else if (node instanceof SwizzleNode) {
@@ -1118,14 +1131,20 @@ class IRComparison extends IRExpression {
             expr = this.func(node, output);
         } else if (node instanceof TransformNode) {
             expr = this.transform(node, output);
+        } else if (node instanceof RotateAboutAxisNode) {
+            expr = this.rotateAboutAxis(node, output);
         } else if (node instanceof VertexColorNode) {
             expr = this.vertexColor(node, output);
         } else if (node instanceof VertexUVNode) {
             expr = this.vertexUV(node, output);
         } else if (node instanceof VertexPositionNode) {
             expr = this.vertexPosition(node, output);
+        } else if (node instanceof PixelWorldPositionNode) {
+            expr = this.pixelWorldPosition(node, output);
         } else if (node instanceof VertexNormalNode) {
             expr = this.vertexNormal(node, output);
+        } else if (node instanceof PixelNormalNode) {
+            expr = this.pixelNormal(node, output);
         } else if (node instanceof VertexTangentNode) {
             expr = this.vertexTangent(node, output);
         } else if (node instanceof VertexBinormalNode) {
@@ -1144,6 +1163,8 @@ class IRComparison extends IRExpression {
             expr = this.billboardMatrix(node, output);
         } else if (node instanceof CameraPositionNode) {
             expr = this.cameraPosition(node, output);
+        } else if (node instanceof CameraVectorNode) {
+            expr = this.cameraVector(node, output);
         } else if (node instanceof CameraNearFarNode) {
             expr = this.cameraNearFar(node, output);
         } else if (node instanceof SkyEnvTextureNode) {
@@ -1272,6 +1293,86 @@ class IRComparison extends IRExpression {
         const input = this.ir(node.inputs[0]);
         return this.getOrCreateIRExpression(node, output, IRFunctionOutput, input);
     }
+    /** Converts a rotate-about-axis node to IR */ rotateAboutAxis(node, output) {
+        const axis = this.ir(node.inputs[0]);
+        const angleTurns = node.inputs[1].inputNode ? this.ir(node.inputs[1]) : new IRConstantf(node.inputs[1].defaultValue?.[0] ?? 0, '');
+        const pivot = node.inputs[2].inputNode ? this.ir(node.inputs[2]) : new IRConstantfv(node.inputs[2].defaultValue ?? [
+            0,
+            0,
+            0
+        ], '', 'vec3');
+        const position = this.ir(node.inputs[3]);
+        const angleRad = new IRFunc([
+            angleTurns,
+            6.283185307179586
+        ], 'mul'); // turns -> radians
+        const cosA = new IRFunc([
+            angleRad
+        ], 'cos');
+        const sinA = new IRFunc([
+            angleRad
+        ], 'sin');
+        const p = new IRFunc([
+            position,
+            pivot
+        ], 'sub');
+        const term1 = new IRFunc([
+            p,
+            cosA
+        ], 'mul');
+        const term2 = new IRFunc([
+            new IRFunc([
+                axis,
+                p
+            ], 'cross'),
+            sinA
+        ], 'mul');
+        const term3 = new IRFunc([
+            axis,
+            new IRFunc([
+                new IRFunc([
+                    axis,
+                    p
+                ], 'dot'),
+                new IRFunc([
+                    1,
+                    cosA
+                ], 'sub')
+            ], 'mul')
+        ], 'mul');
+        const rotated = new IRFunc([
+            new IRFunc([
+                term1,
+                term2
+            ], 'add'),
+            term3
+        ], 'add');
+        return this.getOrCreateIRExpression(node, output, IRFunc, [
+            rotated,
+            pivot
+        ], 'add');
+    }
+    /** Converts a panner node to IR */ panner(node, output) {
+        const coordInput = node.inputs[0];
+        const timeInput = node.inputs[1];
+        const speedInput = node.inputs[2];
+        const coord = coordInput.inputNode ? this.ir(coordInput) : (()=>{
+            this._behaviors.useVertexUV = true;
+            return new IRInput((scope)=>scope.zVertexUV);
+        })();
+        const time = timeInput.inputNode ? this.ir(timeInput) : new IRInput((scope)=>ShaderHelper.getElapsedTime(scope));
+        const speed = speedInput.inputNode ? this.ir(speedInput) : new IRConstantfv(speedInput.defaultValue ?? [
+            0,
+            0
+        ], '', 'vec2');
+        return this.getOrCreateIRExpression(node, output, IRFunc, [
+            coord,
+            new IRFunc([
+                time,
+                speed
+            ], 'mul')
+        ], 'add');
+    }
     /** Converts a vertex color input node to IR */ vertexColor(node, output) {
         this._behaviors.useVertexColor = true;
         return this.getOrCreateIRExpression(node, output, IRInput, (scope)=>scope.zVertexColor);
@@ -1285,6 +1386,9 @@ class IRComparison extends IRExpression {
     /** 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.zVertexNormal);
     }
+    /** Converts a pixel normal input node to IR */ pixelNormal(node, output) {
+        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.zVertexTangent);
     }
@@ -1292,7 +1396,24 @@ class IRComparison extends IRExpression {
         return this.getOrCreateIRExpression(node, output, IRInput, 'zVertexBinormal');
     }
     /** Converts a vertex position input node to IR */ vertexPosition(node, output) {
-        return this.getOrCreateIRExpression(node, output, IRInput, 'zWorldPos');
+        return this.getOrCreateIRExpression(node, output, IRInput, (scope)=>{
+            if (scope.$builder.getDevice().type === 'vertex') {
+                const worldMatrix = ShaderHelper.getWorldMatrix(scope);
+                const basePos = ShaderHelper.resolveVertexPosition(scope);
+                return scope.$builder.mul(worldMatrix, scope.$builder.vec4(basePos, 1)).xyz;
+            }
+            return scope.zWorldPos;
+        });
+    }
+    /** Converts a pixel world position input node to IR */ pixelWorldPosition(node, output) {
+        return this.getOrCreateIRExpression(node, output, IRInput, (scope)=>{
+            if (scope.$builder.getDevice().type === 'vertex') {
+                const worldMatrix = ShaderHelper.getWorldMatrix(scope);
+                const basePos = ShaderHelper.resolveVertexPosition(scope);
+                return scope.$builder.mul(worldMatrix, scope.$builder.vec4(basePos, 1)).xyz;
+            }
+            return scope.zWorldPos;
+        });
     }
     /** Converts a view matrix input node to IR */ viewMatrix(node, output) {
         return this.getOrCreateIRExpression(node, output, IRInput, (scope)=>ShaderHelper.getViewMatrix(scope));
@@ -1312,6 +1433,13 @@ class IRComparison extends IRExpression {
     /** Converts a camera position input node to IR */ cameraPosition(node, output) {
         return this.getOrCreateIRExpression(node, output, IRInput, (scope)=>ShaderHelper.getCameraPosition(scope));
     }
+    /** Converts a camera vector input node to IR */ cameraVector(node, output) {
+        return this.getOrCreateIRExpression(node, output, IRInput, (scope)=>{
+            const pb = scope.$builder;
+            const worldPos = pb.getDevice().type === 'vertex' ? pb.mul(ShaderHelper.getWorldMatrix(scope), pb.vec4(ShaderHelper.resolveVertexPosition(scope), 1)).xyz : scope.zWorldPos;
+            return pb.normalize(pb.sub(ShaderHelper.getCameraPosition(scope), worldPos));
+        });
+    }
     /** Converts a camera near/far input node to IR */ cameraNearFar(node, output) {
         return this.getOrCreateIRExpression(node, output, IRInput, (scope)=>ShaderHelper.getCameraParams(scope).xy);
     }
@@ -1509,10 +1637,26 @@ class IRComparison extends IRExpression {
         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]);
-        const coord = this.ir(node.inputs[1]);
+        const tex = node.inputs[0].inputNode ? this.ir(node.inputs[0]) : this.textureSampleFallbackTexture(node);
+        const coord = node.inputs[1].inputNode ? this.ir(node.inputs[1]) : (()=>{
+            this._behaviors.useVertexUV = true;
+            return new IRInput((scope)=>scope.zVertexUV);
+        })();
         return this.getOrCreateIRExpression(node, output, IRSampleTexture, tex, coord, node.samplerType);
     }
+    /** 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);
+            this._textureSampleFallbackMap.set(node, ir);
+            const uniformTexture = ir.asUniformTexture();
+            if (uniformTexture) {
+                this._uniformTextures.push(uniformTexture);
+            }
+        }
+        return ir;
+    }
 }
 
 export { MaterialBlueprintIR };