@galacean/engine-shader-compiler 2.0.0-alpha.54 → 2.0.0-alpha.56

package/dist/browser.js

@@ -6964,11 +6964,14 @@
         var PostfixExpression = function(ExpressionAstNode) {
             _inherits$1(PostfixExpression, ExpressionAstNode);
             function PostfixExpression() {
-                return ExpressionAstNode.apply(this, arguments) || this;
+                var _this;
+                _this = ExpressionAstNode.apply(this, arguments) || this, _this.resolvedMemberOwners = EMPTY_STRUCT_DECLARATIONS;
+                return _this;
             }
             var _proto = PostfixExpression.prototype;
             _proto.init = function init() {
                 ExpressionAstNode.prototype.init.call(this);
+                this.resolvedMemberOwners = EMPTY_STRUCT_DECLARATIONS;
                 if (this.children.length === 1) {
                     var child = this.children[0];
                     this.type = child.type;
@@ -6985,7 +6988,8 @@
                         if (reference) sa.shaderData.directMemberOwnerReferences.push(reference);
                     }
                     if (typeof base.type === "string") {
-                        PostfixExpression._checkStructField(sa, base.type, children[2], this._branch);
+                        var _PostfixExpression__checkStructField;
+                        this.resolvedMemberOwners = (_PostfixExpression__checkStructField = PostfixExpression._checkStructField(sa, base.type, children[2], this._branch)) != null ? _PostfixExpression__checkStructField : EMPTY_STRUCT_DECLARATIONS;
                     }
                 }
             };
@@ -7031,10 +7035,9 @@
                     sa.reportBranchAmbiguity(field.location, structName + "." + field.lexeme, "struct-member-presence", field.lexeme, structName);
                     return;
                 }
-                if (memberTypeDivergent) {
-                    return;
-                }
-                if (firstProp) return;
+                if (memberTypeDivergent || firstProp) return structs.map(function(symbol) {
+                    return symbol.astNode;
+                });
                 sa.reportUndeclaredStructMember(field.location, structName, field.lexeme);
             };
             return PostfixExpression;
@@ -13718,8 +13721,69 @@
         return Constructor;
     }
 
+    /**
+     * Words that ShaderLab accepts as identifiers but GLSL ES 1.00 or 3.00 reserves. GLES100 output also runs as
+     * GLSL ES 3.00 on WebGL2, so both versions apply to every target.
+     */ var reservedWords = new Set(("asm attribute active atomic_uint case cast centroid class coherent common default double dvec2 dvec3 dvec4 " + "enum extern external filter fixed flat fvec2 fvec3 fvec4 goto half hvec2 hvec3 hvec4 iimage1D iimage1DArray " + "iimage2D iimage2DArray iimage3D iimageBuffer iimageCube image1D image1DArray image2D image2DArray image3D " + "imageBuffer imageCube inline input interface isampler1D isampler1DArray isampler2D isampler2DArray " + "isampler2DMS isampler2DMSArray isampler2DRect isampler3D isamplerBuffer isamplerCube layout long mat2x2 " + "mat2x3 mat2x4 mat3x2 mat3x3 mat3x4 mat4x2 mat4x3 mat4x4 namespace noinline noperspective output packed " + "partition patch public readonly resource restrict sample sampler1D sampler1DArray sampler1DArrayShadow " + "sampler1DShadow sampler2DArray sampler2DArrayShadow sampler2DMS sampler2DMSArray sampler2DRect " + "sampler2DRectShadow sampler2DShadow sampler3D sampler3DRect samplerBuffer samplerCubeShadow short sizeof " + "smooth static subroutine superp switch template this typedef uimage1D uimage1DArray uimage2D uimage2DArray " + "uimage3D uimageBuffer uimageCube uint union unsigned usampler1D usampler1DArray usampler2D usampler2DArray " + "usampler2DMS usampler2DMSArray usampler2DRect usampler3D usamplerBuffer usamplerCube using uvec2 uvec3 uvec4 " + "varying volatile writeonly").split(" "));
+    /**
+     * Tests whether GLSL ES rejects an identifier that ShaderLab accepts.
+     * @param name - Source identifier
+     * @returns Whether the identifier uses a reserved word or namespace
+     * @internal
+     */ function isUnsafeGLSLIdentifier(name) {
+        return reservedWords.has(name) || name.startsWith("gl_") || name.includes("__");
+    }
+    /**
+     * Allocates generated identifiers that avoid source identifiers and each other.
+     * @internal
+     */ var NameAllocator = /*#__PURE__*/ function() {
+        function NameAllocator() {
+            this._used = new Set();
+            this._names = new Map();
+        }
+        var _proto = NameAllocator.prototype;
+        /**
+       * Reserves a source identifier so that generated names never shadow it.
+       * @param name - Source identifier
+       */ _proto.reserve = function reserve(name) {
+            this._used.add(name);
+        };
+        /**
+       * Keeps a source identifier when GLSL accepts it, otherwise assigns a legal name to its identity.
+       * @param key - Source declaration or namespace identity
+       * @param name - Source identifier
+       * @returns Identifier used by the declaration and its references
+       */ _proto.sourceName = function sourceName(key, name) {
+            if (!isUnsafeGLSLIdentifier(name)) return name;
+            return this.allocate(key, name.startsWith("gl_") ? "user_" + name : "" + name + "_");
+        };
+        /**
+       * Returns the same identifier for every request with the same key.
+       * @param key - Identity of the generated declaration, independent of its spelling
+       * @param preferred - Readable base name. Repeated underscores collapse to one, because WebGL rejects `__`
+       * @returns An identifier that differs from every reserved and previously allocated name
+       */ _proto.allocate = function allocate(key, preferred) {
+            var name = this._names.get(key);
+            if (name === undefined) {
+                var base = preferred.replace(/_{2,}/g, "_");
+                var separator = base.endsWith("_") ? "" : "_";
+                name = base;
+                for(var suffix = 1; this._used.has(name); suffix++)name = "" + base + separator + suffix;
+                this._used.add(name);
+                this._names.set(key, name);
+            }
+            return name;
+        };
+        /** Releases all reservations and allocations between compilation requests. */ _proto.reset = function reset() {
+            this._used.clear();
+            this._names.clear();
+        };
+        return NameAllocator;
+    }();
+
     /** @internal */ var VisitorContext = /*#__PURE__*/ function() {
         function VisitorContext() {
+            this.names = new NameAllocator();
             this._lookupSymbol = new SymbolInfo("", null);
             this._structRoles = new Map();
             this._vertexUnresolvedVariableRoles = new Map();
@@ -13736,16 +13800,12 @@
             this._referencedGlobalMacroASTs = [];
             this._structVariableRoles = new Map();
             this.codeCache = new Map();
-            this.fragmentReturnModes = new Map();
-            this.terminalInterfaceReturns = new Set();
             this.reset();
         }
         var _proto = VisitorContext.prototype;
         _proto.reset = function reset(resetAll) {
             if (resetAll === void 0) resetAll = true;
             this.codeCache.clear();
-            this.fragmentReturnModes.clear();
-            this.terminalInterfaceReturns.clear();
             if (resetAll) {
                 this.attributeStructs.length = 0;
                 this.attributeList.length = 0;
@@ -13849,30 +13909,6 @@
             }
             return resolvedRole;
         };
-        /**
-       * Marks a value-return belonging to a fragment entry for backend lowering.
-       * @param statement - Exact return statement identity.
-       * @param mode - Fragment output contract of the containing entry declaration.
-       */ _proto.registerFragmentReturn = function registerFragmentReturn(statement, mode) {
-            this.fragmentReturnModes.set(statement, mode);
-        };
-        /**
-       * Finds the output contract for a fragment-entry return statement.
-       * @param statement - Return statement identity.
-       * @returns Output mode, or `undefined` for ordinary helper/vertex returns.
-       */ _proto.getFragmentReturnMode = function getFragmentReturnMode(statement) {
-            return this.fragmentReturnModes.get(statement);
-        };
-        /** Marks a syntactically final interface return whose control-flow exit can be omitted. */ _proto.registerTerminalInterfaceReturn = function registerTerminalInterfaceReturn(statement) {
-            this.terminalInterfaceReturns.add(statement);
-        };
-        /**
-       * Tests whether an interface return is the final syntactic statement in its function.
-       * @param statement - Return statement identity.
-       * @returns Whether backend lowering may omit a trailing `return;`.
-       */ _proto.isTerminalInterfaceReturn = function isTerminalInterfaceReturn(statement) {
-            return this.terminalInterfaceReturns.has(statement);
-        };
         _proto.referenceAttribute = function referenceAttribute(ident) {
             this._referenceProp(ident.lexeme, this.attributeList, this._referencedAttributeList);
         };
@@ -13949,7 +13985,7 @@
                 var child = _step.value;
                 if (_instanceof(child, BaseToken)) {
                     // Legacy opaque `#define` lexemes carry the directive verbatim; expression-style defines use the AST path
-                    ret.array.push(child.lexeme);
+                    ret.array.push(this.tokenLexeme(child));
                 } else {
                     ret.array.push(child.codeGen(this));
                 }
@@ -13959,6 +13995,16 @@
             pool.return(ret);
             return result;
         };
+        /**
+       * Spells a source token in the generated code.
+       * @param token - Source token
+       * @returns Generated text for the token
+       */ _proto.tokenLexeme = function tokenLexeme(token) {
+            return token.lexeme;
+        };
+        _proto.interfaceMemberName = function interfaceMemberName(name) {
+            return name;
+        };
         _proto.visitPostfixExpression = function visitPostfixExpression(node) {
             var children = node.children;
             var derivationLength = children.length;
@@ -13979,13 +14025,13 @@
                         var unresolvedName = ParserUtils.extractDirectIdentLexeme(postExpr);
                         role = symbols.length ? context.getStructVarRole(symbols) : unresolvedName ? context.getUnresolvedStructVarRole(unresolvedName) : undefined;
                     }
+                    if (!directRoot) role = context.getStructRole(node.resolvedMemberOwners);
                     if (role) {
                         if (role === ShaderStructRole.Attribute) context.referenceAttribute(prop);
                         else if (role === ShaderStructRole.Varying) context.referenceVarying(prop);
                         else context.referenceMRTProp(prop);
-                        return prop.lexeme;
                     }
-                    return postExpr.codeGen(this) + "." + prop.lexeme;
+                    return postExpr.codeGen(this) + "." + (role ? this.interfaceMemberName(prop.lexeme) : prop.lexeme);
                 } else {
                     return postExpr.codeGen(this) + "." + prop.codeGen(this);
                 }
@@ -14020,35 +14066,6 @@
                     var symbol = _step.value;
                     this.referenceFunction(symbol, node.location.start.index, node._branch);
                 }
-                var paramList = call.children[2];
-                if (_instanceof(paramList, ASTNode.FunctionCallParameterList)) {
-                    var astNodes = paramList.paramNodes;
-                    var finalSymbol = this.context._referencedGlobals[call.fnSymbol.ident].find(function(candidate) {
-                        return _instanceof(candidate, FnSymbol) && candidate.equal(call.fnSymbol);
-                    });
-                    var paramInfoList = (finalSymbol != null ? finalSymbol : call.fnSymbol).astNode.protoType.parameterList;
-                    var context = this.context;
-                    var params = astNodes.filter(function(_, i) {
-                        var _paramInfoList_i;
-                        var parameter = paramInfoList == null ? void 0 : (_paramInfoList_i = paramInfoList[i]) == null ? void 0 : _paramInfoList_i.astNode;
-                        // Drop struct-IO parameters (attribute/varying/mrt) — they're flattened
-                        // into top-level declarations and no longer exist as function-call args.
-                        return !_instanceof(parameter, ASTNode.ParameterDeclaration) || !parameter.symbol || !context.getStructVarRole([
-                            parameter.symbol
-                        ]);
-                    });
-                    var paramsCode = "";
-                    for(var i = 0, length = params.length; i < length; i++){
-                        var astNode = params[i];
-                        var code = astNode.codeGen(this);
-                        if (_instanceof(astNode, ASTNode.MacroCallArgBlock) || i === 0) {
-                            paramsCode += code;
-                        } else {
-                            paramsCode += ", " + code;
-                        }
-                    }
-                    return call.fnSymbol.ident + "(" + paramsCode + ")";
-                }
             }
             return this.defaultCodeGen(node.children);
         };
@@ -14057,25 +14074,7 @@
             var paramList = children[2];
             if (_instanceof(paramList, ASTNode.FunctionCallParameterList)) {
                 var astNodes = paramList.paramNodes;
-                var context = this.context;
-                // Drop bare IO-struct args only when the macro aliases a user fn (whose
-                // formal was flattened). All other shapes preserve args verbatim.
-                var params;
-                if (node.isFunctionLikeMacro || !node.aliasesNonBuiltinIdent) {
-                    params = astNodes;
-                } else {
-                    params = astNodes.filter(function(arg) {
-                        if (_instanceof(arg, ASTNode.AssignmentExpression)) {
-                            var variableParam = ParserUtils.unwrapBareIdentifier(arg, {
-                                allowParens: false
-                            });
-                            if (variableParam && context.getStructVarRole(variableParam.resolvedValueSymbols())) {
-                                return false;
-                            }
-                        }
-                        return true;
-                    });
-                }
+                var params = astNodes;
                 var paramsCode = "";
                 for(var i = 0, length = params.length; i < length; i++){
                     var argNode = params[i];
@@ -14101,8 +14100,7 @@
         };
         /**
        * Code-generate a `#define` macro parsed as expression AST. Produces a `#define`
-       * directive whose value is the AST-rewritten string — so varying flattening
-       * happens naturally via `visitPostfixExpression` inside the AST walk.
+       * directive whose value retains ordinary expression and member-access semantics.
        */ _proto.visitMacroDefine = function visitMacroDefine(node) {
             // For function-like macros, preserve the original `(params)` lexeme verbatim —
             // the parameter list is user-authored text that shouldn't be canonicalized.
@@ -14124,79 +14122,27 @@
             var fullType = children[0];
             if (_instanceof(fullType, ASTNode.FullySpecifiedType) && fullType.typeSpecifier.isCustom) {
                 var context = this.context;
-                // Global interface variables are flattened and therefore are not emitted as uniforms.
+                // Global interface variables are mutable shader values, not material bindings.
                 if (context.getStructVarRole([
                     node.declarator.symbol
                 ])) {
-                    return "";
+                    return this.defaultCodeGen(children);
                 }
                 context.referenceGlobal(fullType.type, ESymbolType.STRUCT);
             }
             return "uniform " + this.defaultCodeGen(children);
         };
         _proto.visitDeclaration = function visitDeclaration(node) {
-            var context = this.context;
-            var children = node.children;
-            var child = children[0];
-            if (_instanceof(child, ASTNode.InitDeclaratorList)) {
-                var first = child.children[0];
-                var _child_declarator;
-                var declarator = (_child_declarator = child.declarator) != null ? _child_declarator : _instanceof(first, ASTNode.SingleDeclaration) ? first.declarator : undefined;
-                var role = declarator && context.getStructVarRole([
-                    declarator.symbol
-                ]);
-                if (role === ShaderStructRole.Varying || role === ShaderStructRole.Mrt) return "";
-            }
-            return this.defaultCodeGen(children);
+            return this.defaultCodeGen(node.children);
         };
         _proto.visitFunctionParameterList = function visitFunctionParameterList(node) {
-            var context = this.context;
-            var params = node.parameterInfoList.filter(function(item) {
-                var parameter = item.astNode;
-                return !_instanceof(parameter, ASTNode.ParameterDeclaration) || !parameter.symbol || !context.getStructVarRole([
-                    parameter.symbol
-                ]);
-            });
-            var out = "";
-            for(var i = 0, length = params.length; i < length; i++){
-                var item = params[i];
-                var astNode = item.astNode;
-                var code = astNode.codeGen(this);
-                if (_instanceof(astNode, ASTNode.MacroParamBlock) || i === 0) {
-                    out += code;
-                } else {
-                    out += ", " + code;
-                }
-            }
-            return out;
+            return this.defaultCodeGen(node.children);
         };
         _proto.visitFunctionHeader = function visitFunctionHeader(node) {
-            var returnType = node.returnType.typeSpecifier;
-            if (this.context.getStructRole(returnType.structDeclarations) === ShaderStructRole.Varying) {
-                return "void " + node.ident.lexeme + "(";
-            }
             return this.defaultCodeGen(node.children);
         };
         _proto.visitJumpStatement = function visitJumpStatement(node) {
-            var children = node.children;
-            var cmd = children[0];
-            if (cmd.type === Keyword.RETURN) {
-                var expr = children[1];
-                if (_instanceof(expr, ASTNode.Expression)) {
-                    var returnVar = ParserUtils.unwrapNodeByType(expr, NoneTerminal.variable_identifier);
-                    if (returnVar && this.context.getStructVarRole(returnVar.resolvedValueSymbols()) === ShaderStructRole.Varying) {
-                        return this.context.isTerminalInterfaceReturn(node) ? "" : "return;";
-                    }
-                    var returnFnCall = ParserUtils.unwrapNodeByType(expr, NoneTerminal.function_call);
-                    var calledFunction = returnFnCall == null ? void 0 : returnFnCall.children[0];
-                    var returnDeclarations = _instanceof(calledFunction == null ? void 0 : calledFunction.fnSymbol, FnSymbol) ? calledFunction.fnSymbol.astNode.protoType.returnType.typeSpecifier.structDeclarations : [];
-                    if (this.context.getStructRole(returnDeclarations) === ShaderStructRole.Varying) {
-                        var call = "" + expr.codeGen(this) + ";";
-                        return this.context.isTerminalInterfaceReturn(node) ? call : "{ " + call + " return; }";
-                    }
-                }
-            }
-            return this.defaultCodeGen(children);
+            return this.defaultCodeGen(node.children);
         };
         _proto.visitFunctionIdentifier = function visitFunctionIdentifier(node) {
             return this.defaultCodeGen(node.children);
@@ -14205,63 +14151,10 @@
             return this.defaultCodeGen(node.children);
         };
         _proto.visitStructSpecifier = function visitStructSpecifier(node) {
-            var _this = this;
-            var context = this.context;
-            var varyingStructs = context.varyingStructs, attributeStructs = context.attributeStructs, mrtStructs = context.mrtStructs;
-            var isVaryingStruct = varyingStructs.indexOf(node) !== -1;
-            var isAttributeStruct = attributeStructs.indexOf(node) !== -1;
-            var isMRTStruct = mrtStructs.indexOf(node) !== -1;
-            if (isVaryingStruct || isAttributeStruct || isMRTStruct) {
-                var _result;
-                var result = [];
-                (_result = result).push.apply(_result, [].concat(node.macroExpressions.map(function(item) {
-                    return {
-                        text: _instanceof(item, BaseToken) ? item.lexeme : item.codeGen(_this),
-                        index: item.location.start.index
-                    };
-                })));
-                for(var _iterator = _create_for_of_iterator_helper_loose(node.propList), _step; !(_step = _iterator()).done;){
-                    var prop = _step.value;
-                    var _context__referencedVaryingList_name, _context__referencedAttributeList_name, _context__referencedMRTList_name;
-                    var name = prop.ident.lexeme;
-                    if (isVaryingStruct && ((_context__referencedVaryingList_name = context._referencedVaryingList[name]) == null ? void 0 : _context__referencedVaryingList_name.indexOf(prop)) >= 0) {
-                        result.push({
-                            text: "" + this.getVaryingProp(prop) + "\n",
-                            index: prop.ident.location.start.index
-                        });
-                    } else if (isAttributeStruct && ((_context__referencedAttributeList_name = context._referencedAttributeList[name]) == null ? void 0 : _context__referencedAttributeList_name.indexOf(prop)) >= 0) {
-                        result.push({
-                            text: "" + this.getAttributeProp(prop) + "\n",
-                            index: prop.ident.location.start.index
-                        });
-                    } else if (isMRTStruct && ((_context__referencedMRTList_name = context._referencedMRTList[name]) == null ? void 0 : _context__referencedMRTList_name.indexOf(prop)) >= 0) {
-                        result.push({
-                            text: "" + this.getMRTProp(prop) + "\n",
-                            index: prop.ident.location.start.index
-                        });
-                    }
-                }
-                var text = result.sort(function(a, b) {
-                    return a.index - b.index;
-                }).map(function(item) {
-                    return item.text;
-                }).join("");
-                return text;
-            } else {
-                return this.defaultCodeGen(node.children);
-            }
+            return this.defaultCodeGen(node.children);
         };
         _proto.visitFunctionDefinition = function visitFunctionDefinition(fnNode) {
-            var fnName = fnNode.protoType.ident.lexeme;
-            var context = this.context;
-            var terminal = ParserUtils.lastStatement(fnNode.statements);
-            if (_instanceof(terminal, ASTNode.JumpStatement)) context.registerTerminalInterfaceReturn(terminal);
-            if (fnName == context.stageEntry) {
-                var statements = fnNode.statements.codeGen(this);
-                return "void main() " + statements;
-            } else {
-                return this.defaultCodeGen(fnNode.children);
-            }
+            return this.defaultCodeGen(fnNode.children);
         };
         return CodeGenVisitor;
     }();
@@ -14630,7 +14523,7 @@
         _inherits(GLESVisitor, CodeGenVisitor);
         function GLESVisitor() {
             var _this;
-            _this = CodeGenVisitor.apply(this, arguments) || this, _this._globalCodeArray = [], _this._forwardFunctionDeclarations = new Map(), _this._forwardStructIndices = new Map(), _this._structCodeSegments = new Map(), _this._forwardVariableIndices = new Map(), _this._variableCodeSegments = new Map(), _this._declarationOwners = new Map(), _this._deferredPrototypes = new Map(), _this._declarationReferences = new Map(), _this._outerMacroDeclarations = [];
+            _this = CodeGenVisitor.apply(this, arguments) || this, _this.supportsArrayStructReturn = true, /** Names of pass-scope declarations, which stage-interface globals must not redeclare. */ _this._globalNames = new Set(), /** Interface type and variable tokens whose source names GLSL ES rejects. */ _this._escapedDeclarations = new Map(), _this._fragmentVaryingProps = new Set(), _this._globalInputs = new Map(), _this._inputHelperBodies = new Map(), _this._inputHelperGroups = new Map(), _this._globalCodeArray = [], _this._forwardFunctionDeclarations = new Map(), _this._forwardStructIndices = new Map(), _this._structCodeSegments = new Map(), _this._forwardVariableIndices = new Map(), _this._variableCodeSegments = new Map(), _this._declarationOwners = new Map(), _this._deferredPrototypes = new Map(), _this._declarationReferences = new Map(), _this._outerMacroDeclarations = [];
             return _this;
         }
         var _proto = GLESVisitor.prototype;
@@ -14646,6 +14539,8 @@
             this._variableCodeSegments.clear();
             this._deferredPrototypes.clear();
             this._declarationReferences.clear();
+            this._inputHelperBodies.clear();
+            this._inputHelperGroups.clear();
             this._currentDeclaration = undefined;
         };
         /**
@@ -14653,6 +14548,10 @@
        * @internal
        */ _proto.dispose = function dispose() {
             this.context.reset();
+            this.context.names.reset();
+            this._globalNames.clear();
+            this._escapedDeclarations.clear();
+            this._vertexOutputNames = undefined;
             this.reset();
         };
         /**
@@ -14660,8 +14559,15 @@
        * @param data - Parser-owned shader facts.
        * @param out - Destination code segments.
        */ _proto.getOtherGlobal = function getOtherGlobal(data, out) {
-            for(var _iterator = _create_for_of_iterator_helper_loose(data.globalPrecisions), _step; !(_step = _iterator()).done;){
-                var precision = _step.value;
+            for(var _iterator = _create_for_of_iterator_helper_loose(this._inputHelperGroups.values()), _step; !(_step = _iterator()).done;){
+                var _step_value = _step.value, name = _step_value.name, fallback = _step_value.fallback;
+                out.push({
+                    text: ShaderInstructionEncoder.declaration("void " + name + "() {}", fallback) + ShaderInstructionEncoder.reference(0, fallback.id),
+                    index: -1
+                });
+            }
+            for(var _iterator1 = _create_for_of_iterator_helper_loose(data.globalPrecisions), _step1; !(_step1 = _iterator1()).done;){
+                var precision = _step1.value;
                 out.push({
                     text: precision.codeGen(this),
                     index: precision.location.start.index
@@ -14674,14 +14580,39 @@
        * @param coreInfo - Entry and stage-interface facts derived from the same IR.
        * @returns Generated vertex and fragment source.
        */ _proto.generate = function generate(ir, coreInfo) {
-            var _this = this;
+            var _this, _loop = function(_i, _iter) {
+                var _iter__i = _iter[_i], stage = _iter__i[0], variables = _iter__i[1];
+                var inputRole = stage === EShaderStage.VERTEX ? ShaderStructRole.Attribute : ShaderStructRole.Varying;
+                _this._globalInputs.set(stage, Array.from(variables).filter(function(param) {
+                    var variable = param[0], role = param[1];
+                    return role === inputRole && _instanceof(variable.astNode, ASTNode.VariableDeclaration);
+                }).map(function(param) {
+                    var variable = param[0];
+                    return variable;
+                }));
+            };
+            var _this1 = this;
             var _context_attributeStructs, _context_attributeList, _context_varyingStructs, _context_varyingList, _context_mrtStructs, _context_mrtList;
             this.context.reset();
+            this.context.names.reset();
+            this._globalNames.clear();
+            this._escapedDeclarations.clear();
+            this._vertexOutputNames = undefined;
             this.reset();
             var node = ir.program;
             var shaderData = node.shaderData;
             var context = this.context;
             context._passSymbolTable = shaderData.symbolTable;
+            var hasUnsafeIdentifier = false;
+            var _ir_source_match;
+            for(var _iterator = _create_for_of_iterator_helper_loose((_ir_source_match = ir.source.match(/[A-Za-z_][A-Za-z0-9_]*/g)) != null ? _ir_source_match : []), _step; !(_step = _iterator()).done;){
+                var name = _step.value;
+                context.names.reserve(name);
+                hasUnsafeIdentifier || (hasUnsafeIdentifier = isUnsafeGLSLIdentifier(name));
+            }
+            shaderData.symbolTable.forEach(function(symbol) {
+                return _this1._globalNames.add(symbol.ident);
+            });
             var outerGlobalMacroDeclarations = coreInfo.outerGlobalMacroDeclarations;
             var io = coreInfo.io;
             (_context_attributeStructs = context.attributeStructs).push.apply(_context_attributeStructs, [].concat(io.attributeStructs));
@@ -14702,23 +14633,50 @@
             io.fragmentStructVariableRoles.forEach(function(role, variable) {
                 context.registerStructVar(variable, role, EShaderStage.FRAGMENT);
             });
+            if (hasUnsafeIdentifier) this._collectEscapedDeclarations(node);
+            this._globalInputs.clear();
+            for(var _i = 0, _iter = [
+                [
+                    EShaderStage.VERTEX,
+                    io.vertexStructVariableRoles
+                ],
+                [
+                    EShaderStage.FRAGMENT,
+                    io.fragmentStructVariableRoles
+                ]
+            ]; _i < _iter.length; _i++)_this = this, _loop(_i, _iter);
             this._sourceIR = ir;
             this._outerMacroDeclarations = outerGlobalMacroDeclarations;
             try {
                 coreInfo.deferredDeclarationOwnership.forEach(function(owner, symbol) {
-                    return _this._declarationOwners.set(symbol.astNode, owner);
+                    return _this1._declarationOwners.set(symbol.astNode, owner);
                 });
+                var nextInputOwner = 0;
+                for(var _iterator1 = _create_for_of_iterator_helper_loose(this._declarationOwners.values()), _step1; !(_step1 = _iterator1()).done;){
+                    var owner = _step1.value;
+                    nextInputOwner = Math.max(nextInputOwner, owner.id, owner.group);
+                }
+                for(var _iterator2 = _create_for_of_iterator_helper_loose(this._globalInputs.values()), _step2; !(_step2 = _iterator2()).done;){
+                    var variables = _step2.value;
+                    for(var _iterator3 = _create_for_of_iterator_helper_loose(variables), _step3; !(_step3 = _iterator3()).done;){
+                        var variable = _step3.value;
+                        if (this._declarationOwners.has(variable.astNode)) continue;
+                        var id = ++nextInputOwner;
+                        this._declarationOwners.set(variable.astNode, {
+                            id: id,
+                            group: id,
+                            sourceScope: variable.sourceScope
+                        });
+                    }
+                }
                 if (this._declarationOwners.size) {
-                    var nextId = 0;
-                    var nextGroup = 0;
-                    this._declarationOwners.forEach(function(owner) {
-                        nextId = Math.max(nextId, owner.id);
-                        nextGroup = Math.max(nextGroup, owner.group);
-                    });
+                    // `nextInputOwner` already exceeds every owner id and group.
+                    var nextId = nextInputOwner;
+                    var nextGroup = nextInputOwner;
                     // Reachability follows the selected declaration, including dependencies without an override.
                     shaderData.symbolTable.forEach(function(symbol) {
-                        if (symbol.astNode && !_this._declarationOwners.has(symbol.astNode)) {
-                            _this._declarationOwners.set(symbol.astNode, {
+                        if (symbol.astNode && !_this1._declarationOwners.has(symbol.astNode)) {
+                            _this1._declarationOwners.set(symbol.astNode, {
                                 id: ++nextId,
                                 group: ++nextGroup,
                                 sourceScope: symbol.sourceScope
@@ -14728,54 +14686,71 @@
                     context.onReferenceGlobal = function(symbols) {
                         var _this_currentDeclarationOwner;
                         var _this_currentDeclarationOwner_id;
-                        var from = (_this_currentDeclarationOwner_id = (_this_currentDeclarationOwner = _this.currentDeclarationOwner) == null ? void 0 : _this_currentDeclarationOwner.id) != null ? _this_currentDeclarationOwner_id : 0;
+                        var from = (_this_currentDeclarationOwner_id = (_this_currentDeclarationOwner = _this1.currentDeclarationOwner) == null ? void 0 : _this_currentDeclarationOwner.id) != null ? _this_currentDeclarationOwner_id : 0;
                         for(var _iterator = _create_for_of_iterator_helper_loose(symbols), _step; !(_step = _iterator()).done;){
                             var symbol = _step.value;
-                            _this._referenceDeclaration(from, symbol.astNode);
+                            _this1._referenceDeclaration(from, symbol.astNode);
                         }
                     };
                     var propDeclarations = new Map();
-                    for(var _iterator = _create_for_of_iterator_helper_loose([].concat(io.attributeStructs, io.varyingStructs, io.mrtStructs)), _step; !(_step = _iterator()).done;){
-                        var struct = _step.value;
-                        for(var _iterator1 = _create_for_of_iterator_helper_loose(struct.propList), _step1; !(_step1 = _iterator1()).done;){
-                            var prop = _step1.value;
+                    for(var _iterator4 = _create_for_of_iterator_helper_loose([].concat(io.attributeStructs, io.varyingStructs, io.mrtStructs)), _step4; !(_step4 = _iterator4()).done;){
+                        var struct = _step4.value;
+                        for(var _iterator5 = _create_for_of_iterator_helper_loose(struct.propList), _step5; !(_step5 = _iterator5()).done;){
+                            var prop = _step5.value;
                             propDeclarations.set(prop, struct);
                         }
                     }
                     context.onReferenceStructProps = function(props) {
                         var _this_currentDeclarationOwner;
                         var _this_currentDeclarationOwner_id;
-                        var from = (_this_currentDeclarationOwner_id = (_this_currentDeclarationOwner = _this.currentDeclarationOwner) == null ? void 0 : _this_currentDeclarationOwner.id) != null ? _this_currentDeclarationOwner_id : 0;
+                        var from = (_this_currentDeclarationOwner_id = (_this_currentDeclarationOwner = _this1.currentDeclarationOwner) == null ? void 0 : _this_currentDeclarationOwner.id) != null ? _this_currentDeclarationOwner_id : 0;
                         for(var _iterator = _create_for_of_iterator_helper_loose(props), _step; !(_step = _iterator()).done;){
                             var prop = _step.value;
-                            _this._referenceDeclaration(from, propDeclarations.get(prop));
+                            _this1._referenceDeclaration(from, propDeclarations.get(prop));
                         }
                     };
                 }
                 if (coreInfo.unsupportedDeferredDeclarations.length) {
                     throw mapExpandedShaderError(new GSError(GSErrorName.CompilationError, "Deferred inheritance requires exact signatures and cannot resolve a known partial-coverage conflict.", coreInfo.unsupportedDeferredDeclarations[0].astNode.location, ir.source, undefined, "UnsupportedDeferredDeclaration"), ir.source, ir.sourceMap);
                 }
+                this._fragmentVaryingProps.clear();
+                var fragment = this._fragmentMain(coreInfo.fragmentEntry, shaderData, outerGlobalMacroDeclarations);
+                var vertex = this._vertexMain(coreInfo.vertexEntry, shaderData, outerGlobalMacroDeclarations);
                 return {
-                    vertex: this._vertexMain(coreInfo.vertexEntry, shaderData, outerGlobalMacroDeclarations),
-                    fragment: this._fragmentMain(coreInfo.fragmentEntry, shaderData, outerGlobalMacroDeclarations)
+                    vertex: vertex,
+                    fragment: fragment,
+                    vertexOutputNames: this._vertexOutputNames
                 };
             } finally{
                 this._sourceIR = undefined;
                 this._outerMacroDeclarations = [];
+                this._globalInputs.clear();
                 this._declarationOwners.clear();
                 context.onReferenceGlobal = undefined;
                 context.onReferenceStructProps = undefined;
+                this._fragmentVaryingProps.clear();
+                this._globalNames.clear();
+                this._escapedDeclarations.clear();
+                this._vertexOutputNames = undefined;
+                context.reset();
+                context.names.reset();
             }
         };
         _proto._vertexMain = function _vertexMain(entryInfo, data, outerGlobalMacroDeclarations) {
             var context = this.context;
             context.stage = EShaderStage.VERTEX;
             context.stageEntry = entryInfo.name;
+            for(var _iterator = _create_for_of_iterator_helper_loose(this._fragmentVaryingProps), _step; !(_step = _iterator()).done;){
+                var prop = _step.value;
+                context.referenceVarying(prop.ident);
+            }
             // Attribute/varying structs were collected in ShaderCoreInfo
             // Pre-walk global `#define` values so referenced struct properties emit `attribute`/`varying` declarations.
             this._preRegisterGlobalMacroRefs(outerGlobalMacroDeclarations);
             var globalCodeArray = this._globalCodeArray;
             context.referenceGlobal(entryInfo.name, ESymbolType.FN);
+            this._referenceInterfaceDependencies([].concat(context.attributeStructs, context.varyingStructs));
+            this._initializeGlobalInputs();
             this._getGlobalSymbol(globalCodeArray);
             this._getCustomStruct(context.attributeStructs, globalCodeArray);
             this._getCustomStruct(context.varyingStructs, globalCodeArray);
@@ -14792,28 +14767,17 @@
             return globalCode;
         };
         _proto._fragmentMain = function _fragmentMain(entryInfo, data, outerGlobalMacroStatements) {
-            var _this = this;
             var context = this.context;
             context.stage = EShaderStage.FRAGMENT;
             context.stageEntry = entryInfo.name;
             this.prepareFragment(entryInfo, outerGlobalMacroStatements);
-            // Every value-return must preserve early-exit control flow after entry return values are
-            // lowered into fragment outputs.
-            entryInfo.functions.forEach(function(fnSymbol) {
-                var returnType = fnSymbol.astNode.protoType.returnType;
-                var mode = returnType.type === Keyword.VEC4 ? "color" : returnType.typeSpecifier.structDeclarations.some(function(struct) {
-                    return context.hasStructRole(struct, ShaderStructRole.Mrt);
-                }) ? "mrt" : undefined;
-                if (mode) {
-                    var statements = fnSymbol.astNode.statements;
-                    _this._registerFragmentReturns(statements, mode, ParserUtils.lastStatement(statements));
-                }
-            });
             // Struct-variable identities are already populated from ShaderCoreInfo; just pre-walk macro
             // refs so struct codegen sees the references.
             this._preRegisterGlobalMacroRefs(outerGlobalMacroStatements);
             var globalCodeArray = this._globalCodeArray;
             context.referenceGlobal(entryInfo.name, ESymbolType.FN);
+            this._referenceInterfaceDependencies([].concat(context.varyingStructs, context.mrtStructs));
+            this._initializeGlobalInputs();
             this._getGlobalSymbol(globalCodeArray);
             this._getCustomStruct(context.varyingStructs, globalCodeArray);
             this._getCustomStruct(context.mrtStructs, globalCodeArray);
@@ -14825,10 +14789,347 @@
             }).map(function(item) {
                 return item.text;
             }).join("\n");
-            context.reset();
+            for(var _iterator = _create_for_of_iterator_helper_loose(Object.values(context._referencedVaryingList)), _step; !(_step = _iterator()).done;){
+                var props = _step.value;
+                for(var _iterator1 = _create_for_of_iterator_helper_loose(props), _step1; !(_step1 = _iterator1()).done;){
+                    var prop = _step1.value;
+                    this._fragmentVaryingProps.add(prop);
+                }
+            }
+            context.reset(false);
             this.reset();
             return globalCode;
         };
+        _proto._referenceInterfaceDependencies = function _referenceInterfaceDependencies(structs) {
+            for(var _iterator = _create_for_of_iterator_helper_loose(structs), _step; !(_step = _iterator()).done;){
+                var struct = _step.value;
+                this._currentDeclaration = struct;
+                for(var _iterator1 = _create_for_of_iterator_helper_loose(struct.propList), _step1; !(_step1 = _iterator1()).done;){
+                    var prop = _step1.value;
+                    var _prop_typeInfo_arraySpecifier;
+                    for(var _iterator2 = _create_for_of_iterator_helper_loose(prop.typeInfo.structDeclarations), _step2; !(_step2 = _iterator2()).done;){
+                        var dependency = _step2.value;
+                        if (dependency.ident) this.context.referenceGlobal(dependency.ident.lexeme, ESymbolType.STRUCT);
+                    }
+                    (_prop_typeInfo_arraySpecifier = prop.typeInfo.arraySpecifier) == null ? void 0 : _prop_typeInfo_arraySpecifier.codeGen(this);
+                }
+            }
+            this._currentDeclaration = undefined;
+        };
+        /**
+       * Resolves an interface member's global name, shared by both stages for varyings.
+       * @param prop - Interface member
+       * @param role - Stage-interface role of the member's structure
+       * @returns Generated global identifier
+       */ _proto.interfaceName = function interfaceName(prop, role) {
+            var context = this.context;
+            var name = prop.ident.lexeme;
+            var isOutput = role === ShaderStructRole.Mrt;
+            var sameName = function(item) {
+                return item.ident.lexeme === name;
+            };
+            var conflicts = this._globalNames.has(name) || // Vertex attributes and fragment outputs share a stage scope with varyings.
+            !isOutput && (context.attributeList.some(sameName) || context.mrtList.some(sameName));
+            var key = (isOutput ? "output" : "varying") + ":" + name;
+            var generated = isUnsafeGLSLIdentifier(name) ? context.names.sourceName(key, name) : conflicts ? context.names.allocate(key, name) : name;
+            if (!isOutput && context.stage === EShaderStage.VERTEX && generated !== name) {
+                var _this__vertexOutputNames;
+                ((_this__vertexOutputNames = this._vertexOutputNames) != null ? _this__vertexOutputNames : this._vertexOutputNames = Object.create(null))[name] = generated;
+            }
+            return generated;
+        };
+        _proto.interfaceMemberName = function interfaceMemberName(name) {
+            return this.context.names.sourceName("member:" + name, name);
+        };
+        _proto._interfaceTypeName = function _interfaceTypeName(struct) {
+            var name = struct.ident.lexeme;
+            return this.context.names.sourceName("type:" + name, name);
+        };
+        /**
+       * Escapes interface-typed variables whose names GLSL ES reserves.
+       * @param name - Source name
+       * @param structs - Struct declarations of the variable type
+       * @returns The escaped name, or the source name when no escape is necessary
+       */ _proto._interfaceVariableName = function _interfaceVariableName(name, structs) {
+            return (structs == null ? void 0 : structs.length) && this.context.getStructRole(structs) ? this.context.names.sourceName("variable:" + name, name) : name;
+        };
+        _proto._collectEscapedDeclarations = function _collectEscapedDeclarations(node) {
+            if (_instanceof(node, ASTNode.TypeSpecifier) && this.context.getStructRole(node.structDeclarations)) {
+                var _node_structDeclarations__ident;
+                var token = node.children[0].children[0];
+                if (_instanceof(token, BaseToken) && token.lexeme === ((_node_structDeclarations__ident = node.structDeclarations[0].ident) == null ? void 0 : _node_structDeclarations__ident.lexeme)) {
+                    var name = this._interfaceTypeName(node.structDeclarations[0]);
+                    if (name !== token.lexeme) this._escapedDeclarations.set(token, name);
+                }
+            }
+            var identifier;
+            var structs;
+            if (_instanceof(node, ASTNode.ParameterDeclarator)) {
+                var _node_typeInfo;
+                identifier = node.ident;
+                structs = (_node_typeInfo = node.typeInfo) == null ? void 0 : _node_typeInfo.structDeclarations;
+            } else {
+                var _declarator_typeInfo;
+                // Local, global and multi-variable declarations share the parser's `declarator` record.
+                var declarator = node.declarator;
+                identifier = declarator == null ? void 0 : declarator.identifier;
+                structs = declarator == null ? void 0 : (_declarator_typeInfo = declarator.typeInfo) == null ? void 0 : _declarator_typeInfo.structDeclarations;
+            }
+            if (identifier) {
+                var name1 = this._interfaceVariableName(identifier.lexeme, structs);
+                if (name1 !== identifier.lexeme) this._escapedDeclarations.set(identifier, name1);
+            }
+            for(var _iterator = _create_for_of_iterator_helper_loose(node.children), _step; !(_step = _iterator()).done;){
+                var child = _step.value;
+                if (_instanceof(child, TreeNode)) this._collectEscapedDeclarations(child);
+            }
+        };
+        _proto.tokenLexeme = function tokenLexeme(token) {
+            var _this__escapedDeclarations_get;
+            return (_this__escapedDeclarations_get = this._escapedDeclarations.get(token)) != null ? _this__escapedDeclarations_get : token.lexeme;
+        };
+        _proto._escapedReference = function _escapedReference(node) {
+            var token = node.children[0];
+            if (!this._escapedDeclarations.size || !_instanceof(token, BaseToken) || !isUnsafeGLSLIdentifier(token.lexeme)) {
+                return undefined;
+            }
+            var symbols = node.resolvedValueSymbols();
+            if (!symbols.length) {
+                // Macro values can lack symbols. The stage's unambiguous name-to-role map binds them, as for member access.
+                return this.context.getUnresolvedStructVarRole(token.lexeme) ? this.context.names.sourceName("variable:" + token.lexeme, token.lexeme) : undefined;
+            }
+            var name;
+            for(var _iterator = _create_for_of_iterator_helper_loose(symbols), _step; !(_step = _iterator()).done;){
+                var symbol = _step.value;
+                var _symbol_dataType;
+                var candidate = _instanceof(symbol, VarSymbol) ? this._interfaceVariableName(token.lexeme, (_symbol_dataType = symbol.dataType) == null ? void 0 : _symbol_dataType.structDeclarations) : _instanceof(symbol, StructSymbol) && this.context.getStructRole([
+                    symbol.astNode
+                ]) ? this._interfaceTypeName(symbol.astNode) : token.lexeme;
+                // Branch candidates must agree, otherwise the reference keeps its source spelling.
+                if (name !== undefined && name !== candidate) return undefined;
+                name = candidate;
+            }
+            return name;
+        };
+        _proto._transferName = function _transferName(struct, read) {
+            return this.context.names.allocate((read ? "read" : "write") + ":" + struct.ident.lexeme, (read ? "read" : "write") + "_" + struct.ident.lexeme);
+        };
+        _proto.visitStructSpecifier = function visitStructSpecifier(node) {
+            var _this = this;
+            var context = this.context;
+            var role = context.getStructRole([
+                node
+            ]);
+            if (!role) return CodeGenVisitor.prototype.visitStructSpecifier.call(this, node);
+            var typeName = this._interfaceTypeName(node);
+            var memberCode = function(emit) {
+                var segments = node.macroExpressions.map(function(item) {
+                    return {
+                        text: _instanceof(item, BaseToken) ? item.lexeme : item.codeGen(_this),
+                        index: item.location.start.index
+                    };
+                });
+                for(var _iterator = _create_for_of_iterator_helper_loose(node.propList), _step; !(_step = _iterator()).done;){
+                    var prop = _step.value;
+                    if (!retain(prop)) continue;
+                    segments.push({
+                        text: emit(prop),
+                        index: prop.ident.location.start.index
+                    });
+                }
+                return segments.sort(function(a, b) {
+                    return a.index - b.index;
+                }).map(function(item) {
+                    return item.text;
+                }).join("\n");
+            };
+            var references = role === ShaderStructRole.Attribute ? context._referencedAttributeList : role === ShaderStructRole.Varying ? context._referencedVaryingList : context._referencedMRTList;
+            var used = function(prop) {
+                var _references_prop_ident_lexeme;
+                return !!((_references_prop_ident_lexeme = references[prop.ident.lexeme]) == null ? void 0 : _references_prop_ident_lexeme.includes(prop));
+            };
+            // Interface members have no array wire form, and GLSL ES 1.00 functions cannot return structures that contain
+            // arrays. GLES100 therefore omits array members from interface structures.
+            var retain = function(prop) {
+                return _this.supportsArrayStructReturn || !_this._containsArray(prop);
+            };
+            var declaration = function(prop) {
+                var _prop_typeInfo_arraySpecifier;
+                var _prop_typeInfo_arraySpecifier_codeGen;
+                return prop.typeInfo.typeLexeme + " " + _this.interfaceMemberName(prop.ident.lexeme) + ((_prop_typeInfo_arraySpecifier_codeGen = (_prop_typeInfo_arraySpecifier = prop.typeInfo.arraySpecifier) == null ? void 0 : _prop_typeInfo_arraySpecifier.codeGen(_this)) != null ? _prop_typeInfo_arraySpecifier_codeGen : "") + ";";
+            };
+            var structCode;
+            var hasRetainedField = node.propList.some(retain);
+            if (hasRetainedField && !node.macroExpressions.length) {
+                structCode = "struct " + typeName + " {\n" + memberCode(declaration) + "\n};";
+            } else {
+                var hasFields = context.names.allocate(node, "" + typeName + "_has_fields");
+                var padding = context.names.allocate("empty-interface-member", "interface_padding");
+                // A macro configuration can remove every source field; GLSL still requires a nonempty struct.
+                structCode = "#undef " + hasFields + "\nstruct " + typeName + " {\n" + memberCode(function(prop) {
+                    return declaration(prop) + "\n#define " + hasFields + "\n";
+                }) + "\n#ifndef " + hasFields + "\nfloat " + padding + ";\n#endif\n};\n#undef " + hasFields + "\n";
+            }
+            var declarations = memberCode(function(prop) {
+                var _this_getMRTProp;
+                return !used(prop) ? "" : role === ShaderStructRole.Attribute ? _this.getAttributeProp(prop) : role === ShaderStructRole.Varying ? _this.getVaryingProp(prop) : (_this_getMRTProp = _this.getMRTProp(prop)) != null ? _this_getMRTProp : "";
+            });
+            var read = role === ShaderStructRole.Attribute || role === ShaderStructRole.Varying && context.stage === EShaderStage.FRAGMENT;
+            var value = context.names.allocate("interface-value", "interface_value");
+            var assignments = memberCode(function(prop) {
+                if (!used(prop)) return "";
+                var wire = role === ShaderStructRole.Attribute ? prop.ident.lexeme : role === ShaderStructRole.Mrt ? _this.mrtOutput(prop) : _this.interfaceName(prop, role);
+                var member = value + "." + _this.interfaceMemberName(prop.ident.lexeme);
+                return read ? member + " = " + wire + ";" : wire + " = " + member + ";";
+            });
+            var transfer = read ? typeName + " " + this._transferName(node, true) + "() { " + typeName + " " + value + ";\n" + assignments + "\nreturn " + value + "; }" : "void " + this._transferName(node, false) + "(" + typeName + " " + value + ") {\n" + assignments + "\n}";
+            return structCode + "\n" + declarations + "\n" + transfer;
+        };
+        _proto._containsArray = function _containsArray(prop, visited) {
+            var _this = this;
+            if (visited === void 0) visited = new Set();
+            if (prop.typeInfo.arraySpecifier) return true;
+            for(var _iterator = _create_for_of_iterator_helper_loose(prop.typeInfo.structDeclarations), _step; !(_step = _iterator()).done;){
+                var struct = _step.value;
+                if (visited.has(struct)) continue;
+                visited.add(struct);
+                if (struct.propList.some(function(member) {
+                    return _this._containsArray(member, visited);
+                })) return true;
+            }
+            return false;
+        };
+        _proto.defaultCodeGen = function defaultCodeGen(children) {
+            var _this = this;
+            var parent = _instanceof(children[0], TreeNode) ? children[0].parent : undefined;
+            if (_instanceof(parent, ASTNode.EqualityExpression) && children.length === 3) {
+                var observe = function(node) {
+                    if (_instanceof(node, ASTNode.VariableIdentifier)) {
+                        for(var _iterator = _create_for_of_iterator_helper_loose(node.resolvedValueSymbols()), _step; !(_step = _iterator()).done;){
+                            var symbol = _step.value;
+                            var _symbol_dataType;
+                            var _symbol_dataType_structDeclarations;
+                            if (_instanceof(symbol, VarSymbol)) for(var _iterator1 = _create_for_of_iterator_helper_loose((_symbol_dataType_structDeclarations = (_symbol_dataType = symbol.dataType) == null ? void 0 : _symbol_dataType.structDeclarations) != null ? _symbol_dataType_structDeclarations : []), _step1; !(_step1 = _iterator1()).done;){
+                                var struct = _step1.value;
+                                _this._observeWholeStruct(struct);
+                            }
+                        }
+                    }
+                    if (_instanceof(node, ASTNode.FunctionCallGeneric)) {
+                        var _node_fnSymbol;
+                        var declaration = (_node_fnSymbol = node.fnSymbol) == null ? void 0 : _node_fnSymbol.astNode;
+                        if (_instanceof(declaration, ASTNode.StructSpecifier)) _this._observeWholeStruct(declaration);
+                        else if (_instanceof(declaration, ASTNode.FunctionDefinition)) {
+                            for(var _iterator2 = _create_for_of_iterator_helper_loose(declaration.protoType.returnType.typeSpecifier.structDeclarations), _step2; !(_step2 = _iterator2()).done;){
+                                var struct1 = _step2.value;
+                                _this._observeWholeStruct(struct1);
+                            }
+                        }
+                    }
+                    for(var _iterator3 = _create_for_of_iterator_helper_loose(node.children), _step3; !(_step3 = _iterator3()).done;){
+                        var child = _step3.value;
+                        if (_instanceof(child, TreeNode)) observe(child);
+                    }
+                };
+                for(var _iterator = _create_for_of_iterator_helper_loose(children), _step; !(_step = _iterator()).done;){
+                    var child = _step.value;
+                    if (_instanceof(child, TreeNode) && typeof child.type === "string") observe(child);
+                }
+            }
+            return CodeGenVisitor.prototype.defaultCodeGen.call(this, children);
+        };
+        _proto._observeWholeStruct = function _observeWholeStruct(struct) {
+            var role = this.context.getStructRole([
+                struct
+            ]);
+            for(var _iterator = _create_for_of_iterator_helper_loose(struct.propList), _step; !(_step = _iterator()).done;){
+                var prop = _step.value;
+                if (role === ShaderStructRole.Attribute) this.context.referenceAttribute(prop.ident);
+                else if (role === ShaderStructRole.Varying) this.context.referenceVarying(prop.ident);
+                else if (role === ShaderStructRole.Mrt) this.context.referenceMRTProp(prop.ident);
+            }
+        };
+        _proto.visitFunctionHeader = function visitFunctionHeader(node) {
+            if (node.ident.lexeme === "main" && this.context.stageEntry === "main") {
+                return node.returnType.codeGen(this) + " " + this.context.names.allocate("entry-main", "entry_main") + "(";
+            }
+            return CodeGenVisitor.prototype.visitFunctionHeader.call(this, node);
+        };
+        _proto.visitFunctionIdentifier = function visitFunctionIdentifier(node) {
+            var call = node.parent;
+            if (node.lexeme === "main" && this.context.stageEntry === "main" && _instanceof(call, ASTNode.FunctionCallGeneric) && _instanceof(call.fnSymbol, FnSymbol)) {
+                return this.context.names.allocate("entry-main", "entry_main");
+            }
+            return CodeGenVisitor.prototype.visitFunctionIdentifier.call(this, node);
+        };
+        _proto.visitFunctionDefinition = function visitFunctionDefinition(fnNode) {
+            var definition = CodeGenVisitor.prototype.visitFunctionDefinition.call(this, fnNode);
+            if (fnNode.protoType.ident.lexeme !== this.context.stageEntry) return definition;
+            var args = [];
+            var parameters = [];
+            var _fnNode_protoType_parameterList;
+            for(var _iterator = _create_for_of_iterator_helper_loose((_fnNode_protoType_parameterList = fnNode.protoType.parameterList) != null ? _fnNode_protoType_parameterList : []), _step; !(_step = _iterator()).done;){
+                var parameter = _step.value;
+                if (!parameter.ident || !parameter.typeInfo) continue;
+                var struct = parameter.typeInfo.structDeclarations[0];
+                if (struct) {
+                    var name = this.context.names.allocate(parameter, "input_" + parameter.ident.lexeme);
+                    parameters.push(this._interfaceTypeName(struct) + " " + name + " = " + this._transferName(struct, true) + "();");
+                    args.push(name);
+                }
+            }
+            var name1 = fnNode.protoType.ident.lexeme;
+            var entryName = name1 === "main" ? this.context.names.allocate("entry-main", "entry_main") : name1;
+            var call = entryName + "(" + args.join(", ") + ")";
+            var type = fnNode.protoType.returnType;
+            var struct1 = type.typeSpecifier.structDeclarations[0];
+            var statement;
+            if (struct1) {
+                statement = this._transferName(struct1, false) + "(" + call + ");";
+            } else if (this.context.stage === EShaderStage.FRAGMENT && type.type === Keyword.VEC4) {
+                statement = this.fragmentColorOutput() + " = " + call + ";";
+            } else statement = "" + call + ";";
+            var inputs = this._initializeGlobalInputs();
+            return definition + "\nvoid main() {\n" + inputs.join("\n") + "\n" + parameters.join("\n") + "\n" + statement + " }";
+        };
+        _proto._initializeGlobalInputs = function _initializeGlobalInputs() {
+            var calls = new Set();
+            var _this__globalInputs_get;
+            for(var _iterator = _create_for_of_iterator_helper_loose((_this__globalInputs_get = this._globalInputs.get(this.context.stage)) != null ? _this__globalInputs_get : []), _step; !(_step = _iterator()).done;){
+                var variable = _step.value;
+                this.context.referenceGlobal(variable.ident, ESymbolType.VAR);
+                var struct = variable.dataType.structDeclarations[0];
+                var owner = this._declarationOwners.get(variable.astNode);
+                this._referenceDeclaration(owner.id, struct);
+                var group = this._inputHelperGroups.get(owner.group);
+                if (!group) {
+                    var nextId = 0;
+                    for(var _iterator1 = _create_for_of_iterator_helper_loose(this._declarationOwners.values()), _step1; !(_step1 = _iterator1()).done;){
+                        var declaration = _step1.value;
+                        nextId = Math.max(nextId, declaration.id);
+                    }
+                    for(var _iterator2 = _create_for_of_iterator_helper_loose(this._inputHelperGroups.values()), _step2; !(_step2 = _iterator2()).done;){
+                        var helper = _step2.value;
+                        nextId = Math.max(nextId, helper.fallback.id);
+                    }
+                    // A missing conditional input selects the no-op; an active declaration selects its own initializer.
+                    var fallback = {
+                        id: nextId + 1,
+                        group: owner.group,
+                        sourceScope: -1
+                    };
+                    var name = this.context.names.allocate("input-initializer:" + owner.group, "initialize_" + variable.ident);
+                    this._inputHelperGroups.set(owner.group, group = {
+                        name: name,
+                        fallback: fallback
+                    });
+                }
+                var target = this._interfaceVariableName(variable.ident, variable.dataType.structDeclarations);
+                this._inputHelperBodies.set(variable.astNode, "void " + group.name + "() { " + target + " = " + this._transferName(struct, true) + "(); }");
+                calls.add("" + group.name + "();");
+            }
+            return Array.from(calls);
+        };
         _proto.prepareFragment = function prepareFragment(entryInfo, outerGlobalMacroStatements) {
         };
         /**
@@ -14858,17 +15159,6 @@
                 }
             }
         };
-        _proto._registerFragmentReturns = function _registerFragmentReturns(node, mode, terminal) {
-            if (_instanceof(node, ASTNode.JumpStatement) && node.children.length === 3) {
-                this.context.registerFragmentReturn(node, mode);
-                if (node === terminal) this.context.registerTerminalInterfaceReturn(node);
-                return;
-            }
-            for(var _iterator = _create_for_of_iterator_helper_loose(node.children), _step; !(_step = _iterator()).done;){
-                var child = _step.value;
-                if (_instanceof(child, TreeNode)) this._registerFragmentReturns(child, mode, terminal);
-            }
-        };
         _proto._getGlobalSymbol = function _getGlobalSymbol(out) {
             var context = this.context;
             // Set iteration includes dependencies discovered while generating earlier declarations.
@@ -14989,11 +15279,6 @@
                 for(var _iterator2 = _create_for_of_iterator_helper_loose((_prototype_parameterList = prototype.parameterList) != null ? _prototype_parameterList : []), _step2; !(_step2 = _iterator2()).done;){
                     var parameter = _step2.value;
                     var _parameter_typeInfo;
-                    if (_instanceof(parameter.astNode, ASTNode.ParameterDeclaration) && parameter.astNode.symbol && this.context.getStructVarRole([
-                        parameter.astNode.symbol
-                    ])) {
-                        continue;
-                    }
                     var _parameter_typeInfo_structDeclarations;
                     this._prepareForwardTypes((_parameter_typeInfo_structDeclarations = (_parameter_typeInfo = parameter.typeInfo) == null ? void 0 : _parameter_typeInfo.structDeclarations) != null ? _parameter_typeInfo_structDeclarations : [], anchor, typeAnchor);
                 }
@@ -15001,12 +15286,9 @@
             }
         };
         _proto._getForwardSignature = function _getForwardSignature(prototype) {
-            var _this, _loop = function() {
+            var _loop = function() {
                 var parameter = _step.value;
                 var declaration = parameter.astNode;
-                if (_instanceof(declaration, ASTNode.ParameterDeclaration) && declaration.symbol && _this.context.getStructVarRole([
-                    declaration.symbol
-                ])) return "continue";
                 var tokens = [];
                 var visit = function(node) {
                     if (_instanceof(node, BaseToken)) {
@@ -15021,7 +15303,7 @@
             };
             var parameters = [];
             var _prototype_parameterList;
-            for(var _iterator = _create_for_of_iterator_helper_loose((_prototype_parameterList = prototype.parameterList) != null ? _prototype_parameterList : []), _step; !(_step = _iterator()).done;)_this = this, _loop();
+            for(var _iterator = _create_for_of_iterator_helper_loose((_prototype_parameterList = prototype.parameterList) != null ? _prototype_parameterList : []), _step; !(_step = _iterator()).done;)_loop();
             return prototype.returnType.codeGen(this) + "(" + parameters.join(",") + ")";
         };
         _proto._canBranchesOverlap = function _canBranchesOverlap(left, right) {
@@ -15074,7 +15356,8 @@
             };
             var code = CodeGenVisitor.prototype.visitVariableIdentifier.call(this, node);
             for(var _iterator = _create_for_of_iterator_helper_loose(node.resolvedSymbols()), _step; !(_step = _iterator()).done;)_this = this, _loop();
-            return code;
+            var _this__escapedReference;
+            return (_this__escapedReference = this._escapedReference(node)) != null ? _this__escapedReference : code;
         };
         _proto._getForwardDeclarations = function _getForwardDeclarations(out) {
             var _this, _loop = function() {
@@ -15250,6 +15533,7 @@
         _proto._getCustomStruct = function _getCustomStruct(structNodes, out) {
             for(var _iterator = _create_for_of_iterator_helper_loose(structNodes), _step; !(_step = _iterator()).done;){
                 var node = _step.value;
+                if (this._structCodeSegments.has(node)) continue;
                 var text = node.codeGen(this);
                 if (!node.isInMacroBranch) {
                     out.push({
@@ -15374,7 +15658,8 @@
         };
         _proto._declaration = function _declaration(text, node, activate) {
             if (activate === void 0) activate = true;
-            return ShaderInstructionEncoder.declaration(text, this._declarationOwners.get(node), activate);
+            var initializer = text && this._inputHelperBodies.get(node);
+            return ShaderInstructionEncoder.declaration(initializer ? text + "\n" + initializer : text, this._declarationOwners.get(node), activate);
         };
         _create_class(GLESVisitor, [
             {
@@ -15390,57 +15675,29 @@
     var GLES100Visitor = /*#__PURE__*/ function(GLESVisitor) {
         _inherits(GLES100Visitor, GLESVisitor);
         function GLES100Visitor() {
-            return GLESVisitor.apply(this, arguments) || this;
+            var _this;
+            _this = GLESVisitor.apply(this, arguments) || this, _this.supportsArrayStructReturn = false;
+            return _this;
         }
         var _proto = GLES100Visitor.prototype;
         _proto.getAttributeProp = function getAttributeProp(prop) {
             return "attribute " + prop.typeInfo.typeLexeme + " " + prop.ident.lexeme + ";";
         };
         _proto.getVaryingProp = function getVaryingProp(prop) {
-            return "varying " + prop.typeInfo.typeLexeme + " " + prop.ident.lexeme + ";";
+            return "varying " + prop.typeInfo.typeLexeme + " " + this.interfaceName(prop, ShaderStructRole.Varying) + ";";
         };
         _proto.getMRTProp = function getMRTProp() {
             return "";
         };
-        _proto.visitPostfixExpression = function visitPostfixExpression(node) {
-            var children = node.children;
-            var postExpr = children[0];
-            var context = this.context;
-            var directRoot = _instanceof(postExpr, ASTNode.PostfixExpression) ? ParserUtils.unwrapBareIdentifier(postExpr, {
-                allowParens: true
-            }) : undefined;
-            var _directRoot_resolvedValueSymbols;
-            var directSymbols = (_directRoot_resolvedValueSymbols = directRoot == null ? void 0 : directRoot.resolvedValueSymbols()) != null ? _directRoot_resolvedValueSymbols : [];
-            var unresolvedName = _instanceof(postExpr, ASTNode.PostfixExpression) ? ParserUtils.extractDirectIdentLexeme(postExpr) : null;
-            var directRole = directRoot ? directSymbols.length ? context.getStructVarRole(directSymbols) : unresolvedName ? context.getUnresolvedStructVarRole(unresolvedName) : undefined : undefined;
-            if (directRole === ShaderStructRole.Mrt) {
-                var propReferenced = children[2];
-                var prop = context.mrtList.find(function(item) {
-                    return item.ident.lexeme === propReferenced.lexeme;
-                });
-                // The parser already validated struct fields (UndeclaredStructMember); a miss here is an
-                // already-errored shader, so emit nothing rather than re-report.
-                if (!prop) return "";
-                return "gl_FragData[" + prop.mrtIndex + "]";
-            }
-            return GLESVisitor.prototype.visitPostfixExpression.call(this, node);
+        _proto.fragmentColorOutput = function fragmentColorOutput() {
+            return "gl_FragColor";
         };
-        _proto.visitJumpStatement = function visitJumpStatement(node) {
-            var mode = this.context.getFragmentReturnMode(node);
-            var terminal = this.context.isTerminalInterfaceReturn(node);
-            if (mode === "mrt") return terminal ? "" : "return;";
-            if (mode === "color") {
-                var expression = node.children[1];
-                var assignment = "gl_FragColor = " + expression.codeGen(this) + ";";
-                return terminal ? assignment : "{ " + assignment + " return; }";
-            }
-            return GLESVisitor.prototype.visitJumpStatement.call(this, node);
+        _proto.mrtOutput = function mrtOutput(prop) {
+            return "gl_FragData[" + prop.mrtIndex + "]";
         };
         return GLES100Visitor;
     }(GLESVisitor);
 
-    var V3_GL_FragColor = "GS_glFragColor";
-    var V3_GL_FragData = "GS_glFragData";
     var GLES300Visitor = /*#__PURE__*/ function(GLESVisitor) {
         _inherits(GLES300Visitor, GLESVisitor);
         function GLES300Visitor() {
@@ -15472,15 +15729,15 @@
         };
         _proto.getVaryingProp = function getVaryingProp(prop) {
             var qualifier = this.context.stage === EShaderStage.FRAGMENT ? "in" : "out";
-            return qualifier + " " + prop.typeInfo.typeLexeme + " " + prop.ident.lexeme + ";";
+            return qualifier + " " + prop.typeInfo.typeLexeme + " " + this.interfaceName(prop, ShaderStructRole.Varying) + ";";
         };
         _proto.getMRTProp = function getMRTProp(prop) {
-            return "layout(location = " + prop.mrtIndex + ") out vec4 " + prop.ident.lexeme + ";";
+            return "layout(location = " + prop.mrtIndex + ") out vec4 " + this.interfaceName(prop, ShaderStructRole.Mrt) + ";";
         };
         _proto.visitFunctionIdentifier = function visitFunctionIdentifier(node) {
             var children = node.children;
             var typeSpecifier = children[0];
-            if (typeSpecifier.children.length !== 1 || typeSpecifier.structDependencies.length) {
+            if (!node.isBuiltin || typeSpecifier.children.length !== 1 || typeSpecifier.structDependencies.length) {
                 // Struct constructors still need the shared type-dependency visitor.
                 return GLESVisitor.prototype.visitFunctionIdentifier.call(this, node);
             }
@@ -15514,14 +15771,14 @@
             var context = this.context;
             if (context.stage === EShaderStage.FRAGMENT && node.builtinSemantic === ShaderBuiltinSemantic.FragmentOutput0) {
                 this._registerFragColorVariable();
-                return V3_GL_FragColor;
+                return this._fragmentColorName();
             }
             if (context.stage === EShaderStage.FRAGMENT && node.builtinSemantic === ShaderBuiltinSemantic.FragmentDepth) {
                 return "gl_FragDepth";
             }
             if (context.stage === EShaderStage.FRAGMENT && node.builtinSemantic === ShaderBuiltinSemantic.FragmentOutputArray) {
                 this._registerFragDataArray();
-                return V3_GL_FragData;
+                return this._fragmentDataName();
             }
             return GLESVisitor.prototype.visitVariableIdentifier.call(this, node);
         };
@@ -15532,20 +15789,22 @@
             }
             return GLESVisitor.prototype.visitPostfixExpression.call(this, node);
         };
-        _proto.visitJumpStatement = function visitJumpStatement(node) {
-            var mode = this.context.getFragmentReturnMode(node);
-            var terminal = this.context.isTerminalInterfaceReturn(node);
-            if (mode === "mrt") return terminal ? "" : "return;";
-            if (mode === "color") {
-                this._registerFragColorVariable();
-                var expression = node.children[1];
-                var assignment = V3_GL_FragColor + " = " + expression.codeGen(this) + ";";
-                return terminal ? assignment : "{ " + assignment + " return; }";
-            }
-            return GLESVisitor.prototype.visitJumpStatement.call(this, node);
+        _proto.fragmentColorOutput = function fragmentColorOutput() {
+            this._registerFragColorVariable();
+            return this._fragmentColorName();
+        };
+        _proto.mrtOutput = function mrtOutput(prop) {
+            return this.interfaceName(prop, ShaderStructRole.Mrt);
+        };
+        _proto._fragmentColorName = function _fragmentColorName() {
+            return this.context.names.allocate("fragment-output", "output_color");
+        };
+        _proto._fragmentDataName = function _fragmentDataName() {
+            return this.context.names.allocate("fragment-output-array", "output_colors");
         };
         _proto._registerFragColorVariable = function _registerFragColorVariable() {
-            this._registerOutput(V3_GL_FragColor, "out vec4 " + V3_GL_FragColor + ";");
+            var name = this._fragmentColorName();
+            this._registerOutput(name, "out vec4 " + name + ";");
         };
         _proto._registerOutput = function _registerOutput(name, text) {
             var output = this._outputDeclarations.get(name);
@@ -15598,10 +15857,11 @@
             }
         };
         _proto._registerFragDataArray = function _registerFragDataArray() {
-            this._registerOutput(V3_GL_FragData, "layout(location = 0) out vec4 " + V3_GL_FragData + "[gl_MaxDrawBuffers];");
+            var name = this._fragmentDataName();
+            this._registerOutput(name, "layout(location = 0) out vec4 " + name + "[gl_MaxDrawBuffers];");
         };
         _proto._registerFragDataVariable = function _registerFragDataVariable(index) {
-            var name = "" + V3_GL_FragData + index;
+            var name = this.context.names.allocate("fragment-output:" + index, "output_color_" + index);
             this._registerOutput(name, "layout(location = " + index + ") out vec4 " + name + ";");
             return name;
         };
@@ -15790,7 +16050,7 @@
 
     /**
      * Version of the shader compiler package, replaced with the package version during builds.
-     */ var version = "2.0.0-alpha.54";
+     */ var version = "2.0.0-alpha.56";
     engineCore.Logger.info("Galacean Engine Shader Compiler Version: " + version);
 
     exports.GSError = GSError;