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

package/dist/precompile.module.js

@@ -1,7 +1,7 @@
 import { normalizeShaderIncludeMap, ShaderSourceParser, parseValidatedShaderPass, ShaderCoreInfo as ShaderCoreInfo$1, branchAnalysis, ParserObjectPool, createValidatedShaderTargetParser } from '@galacean/engine-shader-parser/internal/analyzer';
 import { ReturnableObjectPool, ShaderPreprocessorDirective, Logger, ShaderLanguage } from '@galacean/engine-core';
 import { Color } from '@galacean/engine-math';
-import { SymbolInfo, EShaderStage, VarSymbol, BaseToken, ParserUtils, ShaderStructRole, ESymbolType, FnSymbol, ASTNode, Keyword, NoneTerminal, parsePreprocessorExpression, toPreprocessorCondition, mapExpandedShaderError, GSError, GSErrorName, TreeNode, canInheritanceBranchesCover, getLexicalDeclarationCoexistence, ShaderBuiltinSemantic, GLESShaderInfo, ShaderCoreInfo } from '@galacean/engine-shader-parser/internal';
+import { SymbolInfo, EShaderStage, VarSymbol, BaseToken, ParserUtils, ShaderStructRole, ESymbolType, FnSymbol, ASTNode, parsePreprocessorExpression, toPreprocessorCondition, mapExpandedShaderError, GSError, GSErrorName, TreeNode, StructSymbol, Keyword, canInheritanceBranchesCover, getLexicalDeclarationCoexistence, ShaderBuiltinSemantic, GLESShaderInfo, ShaderCoreInfo } from '@galacean/engine-shader-parser/internal';
 
 function _set_prototype_of(o, p) {
     _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
@@ -152,8 +152,69 @@ function _create_class(Constructor, protoProps, staticProps) {
     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();
@@ -170,16 +231,12 @@ function _create_class(Constructor, protoProps, staticProps) {
         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;
@@ -283,30 +340,6 @@ function _create_class(Constructor, protoProps, staticProps) {
         }
         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);
     };
@@ -383,7 +416,7 @@ var TempArray = /*#__PURE__*/ function() {
             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));
             }
@@ -393,6 +426,16 @@ var TempArray = /*#__PURE__*/ function() {
         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;
@@ -413,13 +456,13 @@ var TempArray = /*#__PURE__*/ function() {
                     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);
             }
@@ -454,35 +497,6 @@ var TempArray = /*#__PURE__*/ function() {
                 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);
     };
@@ -491,25 +505,7 @@ var TempArray = /*#__PURE__*/ function() {
         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];
@@ -535,8 +531,7 @@ var TempArray = /*#__PURE__*/ function() {
     };
     /**
    * 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.
@@ -558,79 +553,27 @@ var TempArray = /*#__PURE__*/ function() {
         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);
@@ -639,63 +582,10 @@ var TempArray = /*#__PURE__*/ function() {
         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;
 }();
@@ -1064,7 +954,7 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
     _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;
@@ -1080,6 +970,8 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
         this._variableCodeSegments.clear();
         this._deferredPrototypes.clear();
         this._declarationReferences.clear();
+        this._inputHelperBodies.clear();
+        this._inputHelperGroups.clear();
         this._currentDeclaration = undefined;
     };
     /**
@@ -1087,6 +979,10 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
    * @internal
    */ _proto.dispose = function dispose() {
         this.context.reset();
+        this.context.names.reset();
+        this._globalNames.clear();
+        this._escapedDeclarations.clear();
+        this._vertexOutputNames = undefined;
         this.reset();
     };
     /**
@@ -1094,8 +990,15 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
    * @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
@@ -1108,14 +1011,39 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
    * @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));
@@ -1136,23 +1064,50 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
         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
@@ -1162,54 +1117,71 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
                 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);
@@ -1226,28 +1198,17 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
         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);
@@ -1259,10 +1220,347 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
         }).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) {
     };
     /**
@@ -1292,17 +1590,6 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
             }
         }
     };
-    _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.
@@ -1423,11 +1710,6 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
             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);
             }
@@ -1435,12 +1717,9 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
         }
     };
     _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)) {
@@ -1455,7 +1734,7 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
         };
         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) {
@@ -1508,7 +1787,8 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
         };
         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() {
@@ -1684,6 +1964,7 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
     _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({
@@ -1808,7 +2089,8 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
     };
     _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, [
         {
@@ -1824,57 +2106,29 @@ ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
 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() {
@@ -1906,15 +2160,15 @@ var GLES300Visitor = /*#__PURE__*/ function(GLESVisitor) {
     };
     _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);
         }
@@ -1948,14 +2202,14 @@ var GLES300Visitor = /*#__PURE__*/ function(GLESVisitor) {
         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);
     };
@@ -1966,20 +2220,22 @@ var GLES300Visitor = /*#__PURE__*/ function(GLESVisitor) {
         }
         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);
@@ -2032,10 +2288,11 @@ var GLES300Visitor = /*#__PURE__*/ function(GLESVisitor) {
         }
     };
     _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;
     };
@@ -2261,6 +2518,7 @@ function generateShaderProgram(ir, coreInfo, backend, preprocessorExpressions) {
                             isUsePass: false,
                             tags: pass.tags,
                             renderStates: serializeRenderStates(pass.renderStates),
+                            vertexOutputNames: program.vertexOutputNames,
                             vertexShaderInstructions: program.vertexShaderInstructions,
                             fragmentShaderInstructions: program.fragmentShaderInstructions
                         };