@galacean/engine-shaderlab 2.0.0-alpha.24 → 2.0.0-alpha.26

package/dist/browser.js

@@ -4,6 +4,12 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.Galacean = global.Galacean || {}, global.Galacean.ShaderLab = {}), global.Galacean));
 })(this, (function (exports, engine) { 'use strict';
 
+    function _instanceof(left, right) {
+        if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+            return !!right[Symbol.hasInstance](left);
+        } else return left instanceof right;
+    }
+
     function _set_prototype_of(o, p) {
         _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
             o.__proto__ = p;
@@ -24,12 +30,6 @@
         if (superClass) _set_prototype_of(subClass, superClass);
     }
 
-    function _instanceof(left, right) {
-        if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-            return !!right[Symbol.hasInstance](left);
-        } else return left instanceof right;
-    }
-
     function _defineProperties(target, props) {
         for (var i = 0; i < props.length; i++) {
             var descriptor = props[i];
@@ -1202,7 +1202,7 @@
         return GSError;
     }(_wrap_native_super(Error));
     GSError.wrappingLineCount = 2;
-    var GSErrorName$1 = /*#__PURE__*/ function(GSErrorName) {
+    var GSErrorName = /*#__PURE__*/ function(GSErrorName) {
         GSErrorName["PreprocessorError"] = "PreprocessorError";
         GSErrorName["CompilationError"] = "CompilationError";
         GSErrorName["ScannerError"] = "ScannerError";
@@ -1338,7 +1338,7 @@
             engine.Logger.error(message);
         };
         _proto.reportWarning = function reportWarning(loc, message) {
-            engine.Logger.warn(new GSError(GSErrorName$1.CompilationWarn, message, loc, ShaderLab._processingPassText).toString());
+            engine.Logger.warn(new GSError(GSErrorName.CompilationWarn, message, loc, ShaderLab._processingPassText).toString());
         };
         _create_class(SemanticAnalyzer, [
             {
@@ -3183,7 +3183,7 @@
                 return item.ident.lexeme === lexeme;
             });
             if (!props.length) {
-                return ShaderLabUtils.createGSError("referenced attribute not found: " + lexeme, GSErrorName$1.CompilationError, ShaderLab._processingPassText, ident.location);
+                return ShaderLabUtils.createGSError("referenced attribute not found: " + lexeme, GSErrorName.CompilationError, ShaderLab._processingPassText, ident.location);
             }
             this._referencedAttributeList[lexeme] = props;
         };
@@ -3194,7 +3194,7 @@
                 return item.ident.lexeme === lexeme;
             });
             if (!props.length) {
-                return ShaderLabUtils.createGSError("referenced varying not found: " + lexeme, GSErrorName$1.CompilationError, ShaderLab._processingPassText, ident.location);
+                return ShaderLabUtils.createGSError("referenced varying not found: " + lexeme, GSErrorName.CompilationError, ShaderLab._processingPassText, ident.location);
             }
             this._referencedVaryingList[lexeme] = props;
         };
@@ -3205,7 +3205,7 @@
                 return item.ident.lexeme === lexeme;
             });
             if (!props.length) {
-                return ShaderLabUtils.createGSError("referenced mrt not found: " + lexeme, GSErrorName$1.CompilationError, ShaderLab._processingPassText, ident.location);
+                return ShaderLabUtils.createGSError("referenced mrt not found: " + lexeme, GSErrorName.CompilationError, ShaderLab._processingPassText, ident.location);
             }
             this._referencedMRTList[lexeme] = props;
         };
@@ -4054,7 +4054,7 @@
             for(var _len = arguments.length, msgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
                 msgs[_key - 1] = arguments[_key];
             }
-            var error = ShaderLabUtils.createGSError(msgs.join(" "), GSErrorName$1.ScannerError, this._source, pos);
+            var error = ShaderLabUtils.createGSError(msgs.join(" "), GSErrorName.ScannerError, this._source, pos);
             throw error;
         };
         _proto.scanPairedChar = function scanPairedChar(left, right, balanced, skipLeading) {
@@ -4625,840 +4625,452 @@
         "#undef": Keyword.MACRO_UNDEF
     };
 
-    function _type_of(obj) {
-        "@swc/helpers - typeof";
-
-        return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-    }
-
-    var MacroParserToken = /*#__PURE__*/ function(MacroParserToken) {
-        MacroParserToken[MacroParserToken["id"] = 0] = "id";
-        MacroParserToken[MacroParserToken["line_remain"] = 1] = "line_remain";
-        MacroParserToken[MacroParserToken["chunk"] = 2] = "chunk";
-        MacroParserToken[MacroParserToken["int_constant"] = 3] = "int_constant";
-        MacroParserToken[MacroParserToken["string_const"] = 4] = "string_const";
-        /** \>> */ MacroParserToken[MacroParserToken["right_op"] = 5] = "right_op";
-        /** << */ MacroParserToken[MacroParserToken["left_op"] = 6] = "left_op";
-        MacroParserToken[MacroParserToken["left_paren"] = 7] = "left_paren";
-        MacroParserToken[MacroParserToken["right_paren"] = 8] = "right_paren";
-        /** \>= */ MacroParserToken[MacroParserToken["ge"] = 9] = "ge";
-        /** <= */ MacroParserToken[MacroParserToken["le"] = 10] = "le";
-        /** == */ MacroParserToken[MacroParserToken["eq"] = 11] = "eq";
-        /** != */ MacroParserToken[MacroParserToken["neq"] = 12] = "neq";
-        /** && */ MacroParserToken[MacroParserToken["and"] = 13] = "and";
-        /** || */ MacroParserToken[MacroParserToken["or"] = 14] = "or";
-        /** < */ MacroParserToken[MacroParserToken["left_angle"] = 15] = "left_angle";
-        /** \> */ MacroParserToken[MacroParserToken["right_angle"] = 16] = "right_angle";
-        /** \* */ MacroParserToken[MacroParserToken["star"] = 17] = "star";
-        /** + */ MacroParserToken[MacroParserToken["plus"] = 18] = "plus";
-        /** \- */ MacroParserToken[MacroParserToken["dash"] = 19] = "dash";
-        /** ! */ MacroParserToken[MacroParserToken["bang"] = 20] = "bang";
-        /** \/ */ MacroParserToken[MacroParserToken["slash"] = 21] = "slash";
-        /** % */ MacroParserToken[MacroParserToken["percent"] = 22] = "percent";
-        MacroParserToken[MacroParserToken["EOF"] = 100] = "EOF";
-        return MacroParserToken;
-    }({});
-    var MacroParserKeyword = /*#__PURE__*/ function(MacroParserKeyword) {
-        MacroParserKeyword[MacroParserKeyword["define"] = 101] = "define";
-        MacroParserKeyword[MacroParserKeyword["undef"] = 102] = "undef";
-        MacroParserKeyword[MacroParserKeyword["if"] = 103] = "if";
-        MacroParserKeyword[MacroParserKeyword["ifdef"] = 104] = "ifdef";
-        MacroParserKeyword[MacroParserKeyword["ifndef"] = 105] = "ifndef";
-        MacroParserKeyword[MacroParserKeyword["else"] = 106] = "else";
-        MacroParserKeyword[MacroParserKeyword["elif"] = 107] = "elif";
-        MacroParserKeyword[MacroParserKeyword["endif"] = 108] = "endif";
-        MacroParserKeyword[MacroParserKeyword["defined"] = 109] = "defined";
-        return MacroParserKeyword;
-    }({});
-
-    var MacroDefine = /*#__PURE__*/ function() {
-        function MacroDefine(macro, body, location, args) {
-            this.macro = macro;
-            this.body = body;
-            this.location = location;
-            this.args = args;
-            if ((args == null ? void 0 : args.length) > 0) {
-                this._argsLexemes = this.args.map(function(item) {
-                    return item.lexeme;
-                });
-                this._replaceRegex = new RegExp("\\b(" + this._argsLexemes.join("|") + ")\\b", "g");
-            }
-        }
-        var _proto = MacroDefine.prototype;
-        _proto.expandFunctionBody = function expandFunctionBody(args) {
-            var _this = this;
-            var _this_args;
-            if (args.length !== ((_this_args = this.args) == null ? void 0 : _this_args.length)) {
-                throw ShaderLabUtils.createGSError("mismatched function macro", GSErrorName.PreprocessorError, "", this.location);
-            }
-            if (args.length === 0) {
-                return this.body.lexeme;
-            }
-            return this.body.lexeme.replace(this._replaceRegex, function(m) {
-                return args[_this._argsLexemes.indexOf(m)];
-            });
-        };
-        _create_class(MacroDefine, [
-            {
-                key: "isFunction",
-                get: function get() {
-                    return !!this.args;
-                }
-            }
-        ]);
-        return MacroDefine;
-    }();
-
-    var MacroParserLexer = /*#__PURE__*/ function(BaseLexer1) {
-        _inherits(MacroParserLexer, BaseLexer1);
-        function MacroParserLexer(source) {
-            var _this;
-            _this = BaseLexer1.call(this, source) || this, _this.macroLvl = 0;
-            return _this;
-        }
-        var _proto = MacroParserLexer.prototype;
-        _proto.scanWordsUntilTerminator = function scanWordsUntilTerminator(terminatorChar) {
-            var tokens = [];
-            while(true){
-                this.skipSpace(true);
-                if (BaseLexer.isAlpha(this.getCurCharCode())) {
-                    tokens.push(this.scanWord());
-                } else if (this.getCurChar() === terminatorChar) {
-                    this.advance(1);
-                    return tokens;
-                } else {
-                    this.advance(1);
-                }
-            }
-        };
-        _proto.scanWord = function scanWord() {
-            // Skip all non-alphabetic characters, primarily used for handling defined(MACRO) syntax
-            while(!BaseLexer.isAlpha(this.getCurCharCode()) && !this.isEnd()){
-                this.advance(1);
-            }
-            if (this.isEnd()) {
-                return EOF;
-            }
-            var start = this._currentIndex;
-            while(BaseLexer.isAlnum(this.getCurCharCode()) && !this.isEnd()){
-                this.advance(1);
-            }
-            var end = this._currentIndex;
-            var word = this._source.slice(start, end);
-            if (end === start) {
-                this.throwError(this.getShaderPosition(0), "no word found.");
-            }
-            var token = BaseToken.pool.get();
-            var _MacroParserLexer__lexemeTable_word;
-            var tokenType = (_MacroParserLexer__lexemeTable_word = MacroParserLexer._lexemeTable[word]) != null ? _MacroParserLexer__lexemeTable_word : MacroParserToken.id;
-            token.set(tokenType, word, this.getShaderPosition(word.length));
-            return token;
-        };
-        _proto.scanToken = function scanToken() {
-            this.skipCommentsAndSpace();
-            if (this.isEnd()) {
-                return;
-            }
-            var source = this._source;
-            var start = this._currentIndex;
-            var found = false;
-            for(var n = source.length; this._currentIndex < n;){
-                if (MacroParserLexer._isPpCharacters(source.charCodeAt(this._currentIndex))) {
-                    this.advance(1);
-                    found = true;
-                } else {
-                    if (found) {
-                        break;
-                    }
-                    this.advance(1);
-                    this.skipCommentsAndSpace();
-                    start = this._currentIndex;
-                }
-            }
-            var lexeme = source.slice(start, this._currentIndex);
-            var token = BaseToken.pool.get();
-            var _MacroParserLexer__lexemeTable_lexeme;
-            var type = (_MacroParserLexer__lexemeTable_lexeme = MacroParserLexer._lexemeTable[lexeme]) != null ? _MacroParserLexer__lexemeTable_lexeme : MacroParserToken.id;
-            token.set(type, lexeme, this.getShaderPosition(this._currentIndex - start));
-            if (type === MacroParserKeyword.if || type === MacroParserKeyword.ifdef || type === MacroParserKeyword.ifndef) {
-                this.macroLvl++;
-            } else if (type === MacroParserKeyword.endif) {
-                this.macroLvl--;
-            }
-            return token;
-        };
-        _proto.scanQuotedString = function scanQuotedString() {
-            this.skipSpace(true);
-            var source = this._source;
-            var sourceLength = source.length;
-            var start = this.getShaderPosition(0);
-            var index = this._currentIndex;
-            // Check for opening quote
-            if (source.charCodeAt(index) !== 34) {
-                // 34 = '"'
-                this.throwError(start, "Unexpected char, expected '\"'");
-            }
-            var contentStart = ++index; // Skip opening quote and record start
-            // Fast scan to closing quote
-            while(index < sourceLength && source.charCodeAt(index) !== 34){
-                index++;
-            }
-            if (index >= sourceLength) {
-                this.throwError(this.getShaderPosition(0), "Unexpected char, expected '\"'");
-            }
-            var lexeme = source.slice(contentStart, index);
-            this.advance(index + 1 - this._currentIndex); // Skip to after closing quote
-            var token = BaseToken.pool.get();
-            token.set(MacroParserToken.string_const, lexeme, start);
-            return token;
-        };
-        _proto.scanToChar = function scanToChar(char) {
-            var source = this._source;
-            while(source[this._currentIndex] !== char && !this.isEnd()){
-                this.advance(1);
-            }
-        };
-        _proto.scanMacroBranchBody = function scanMacroBranchBody() {
-            var shaderPosition = this.getShaderPosition(0);
-            var startLevel = this.macroLvl;
-            var nextDirective = this.scanToken();
-            while(true){
-                var type = nextDirective.type;
-                if (type === MacroParserKeyword.endif && startLevel - 1 === this.macroLvl) {
-                    break;
-                } else if ((type === MacroParserKeyword.elif || type === MacroParserKeyword.else) && startLevel === this.macroLvl) {
+    /** Must stay in sync with ShaderPreprocessorDirective in @galacean/engine-core */ var ShaderPreprocessorDirective = {
+        Text: 0,
+        IfDef: 1,
+        IfNdef: 2,
+        IfCmp: 3,
+        IfExpr: 4,
+        Else: 5,
+        Endif: 6,
+        Define: 7,
+        DefineVal: 8,
+        DefineFunc: 9,
+        Undef: 10
+    };
+    /**
+     * @internal
+     */ var ShaderInstructionEncoder = /*#__PURE__*/ function() {
+        function ShaderInstructionEncoder() {}
+        ShaderInstructionEncoder.parse = function parse(glsl) {
+            var instructions = [];
+            var length = glsl.length;
+            var pos = 0;
+            var backfillStack = [];
+            while(pos < length){
+                var directiveStart = ShaderInstructionEncoder._findDirectiveStart(glsl, pos, length);
+                if (directiveStart === -1) {
+                    ShaderInstructionEncoder._pushText(instructions, glsl, pos, length);
                     break;
                 }
-                nextDirective = this.scanToken();
-            }
-            var lexeme = this._source.slice(shaderPosition.index, this._currentIndex - nextDirective.lexeme.length - 1);
-            var body = BaseToken.pool.get();
-            body.set(MacroParserToken.chunk, lexeme, shaderPosition);
-            return {
-                body: body,
-                nextDirective: nextDirective
-            };
-        };
-        _proto.scanPairedBlock = function scanPairedBlock(lc, rc) {
-            this.scanToChar(lc);
-            var level = 0;
-            var source = this._source;
-            do {
-                var curChar = source[this._currentIndex];
-                if (curChar === lc) {
-                    level++;
-                } else if (curChar === rc) {
-                    level--;
-                }
-                this.advance(1);
-            }while (level > 0);
-        };
-        /**
-       * @returns end ShaderPosition
-       */ _proto.scanRemainMacro = function scanRemainMacro() {
-            var startLvl = this.macroLvl;
-            var directive = this.scanToken();
-            while(!this.isEnd() && (directive.type !== MacroParserKeyword.endif || startLvl - 1 !== this.macroLvl)){
-                directive = this.scanToken();
-            }
-            return this.getShaderPosition(0);
-        };
-        _proto.peekNonSpace = function peekNonSpace() {
-            var current = this._currentIndex;
-            while(/\s/.test(this._source[current])){
-                current += 1;
-            }
-            return this._source[current];
-        };
-        _proto.scanInteger = function scanInteger() {
-            var start = this._currentIndex;
-            while(BaseLexer.isDigit(this.getCurCharCode())){
-                this.advance(1);
-            }
-            if (this._currentIndex === start) {
-                this.throwError(this.getShaderPosition(0), "no integer found");
-            }
-            var integer = this._source.slice(start, this._currentIndex);
-            var token = BaseToken.pool.get();
-            token.set(MacroParserToken.int_constant, integer, this.getShaderPosition(0));
-            return token;
-        };
-        _proto.scanMacroBody = function scanMacroBody() {
-            this.skipSpace(false);
-            var lexeme = "";
-            var source = this._source;
-            var sourceLength = source.length;
-            var start = this.getShaderPosition(0);
-            while(this._currentIndex < sourceLength){
-                var charCode = source.charCodeAt(this._currentIndex);
-                // Check for line break (terminates macro definition), break when encounter "\n"
-                if (charCode === 10) {
-                    break;
+                if (directiveStart > pos) {
+                    ShaderInstructionEncoder._pushText(instructions, glsl, pos, directiveStart);
+                }
+                var lineEnd = glsl.indexOf("\n", directiveStart);
+                if (lineEnd === -1) lineEnd = length;
+                var line = glsl.substring(directiveStart, lineEnd);
+                pos = lineEnd < length ? lineEnd + 1 : length;
+                var match = ShaderInstructionEncoder._DIRECTIVE_RE.exec(line);
+                if (!match) {
+                    var last = instructions.length > 0 ? instructions[instructions.length - 1] : null;
+                    var text = lineEnd < length ? line + "\n" : line;
+                    if (last && last[0] === ShaderPreprocessorDirective.Text) {
+                        last[1] += text;
+                    } else {
+                        instructions.push([
+                            ShaderPreprocessorDirective.Text,
+                            text
+                        ]);
+                    }
+                    continue;
                 }
-                // Check for comments (both single-line and multi-line)
-                if (charCode === 47) {
-                    var nextIndex = this._currentIndex + 1;
-                    if (nextIndex < sourceLength) {
-                        var nextCharCode = source.charCodeAt(nextIndex);
-                        // Single-line comment (terminates macro definition), break when encounter "//"
-                        if (nextCharCode === 47) {
+                var keyword = match[1];
+                var rest = match[2].trim();
+                switch(keyword){
+                    case "ifdef":
+                        {
+                            var idx = instructions.length;
+                            instructions.push([
+                                ShaderPreprocessorDirective.IfDef,
+                                rest,
+                                -1
+                            ]);
+                            backfillStack.push([
+                                idx
+                            ]);
+                            break;
+                        }
+                    case "ifndef":
+                        {
+                            var idx1 = instructions.length;
+                            instructions.push([
+                                ShaderPreprocessorDirective.IfNdef,
+                                rest,
+                                -1
+                            ]);
+                            backfillStack.push([
+                                idx1
+                            ]);
                             break;
                         }
-                        // Multi-line comment (skip but don't terminate)
-                        if (nextCharCode === 42) {
-                            this.advance(2); // Skip "/*"
-                            // Skip until end of multi-line comment
-                            while(this._currentIndex + 1 < sourceLength){
-                                var currentIndex = this._currentIndex;
-                                if (source.charCodeAt(currentIndex) === 42 && source.charCodeAt(currentIndex + 1) === 47) {
-                                    this.advance(2); // Skip "*/
-                                    break;
+                    case "if":
+                        {
+                            var cond = ShaderInstructionEncoder._parseCondition(rest);
+                            var idx2 = instructions.length;
+                            ShaderInstructionEncoder._pushConditionInstruction(instructions, cond);
+                            backfillStack.push([
+                                idx2
+                            ]);
+                            break;
+                        }
+                    case "elif":
+                        {
+                            var stack = backfillStack[backfillStack.length - 1];
+                            var prevIdx = stack[stack.length - 1];
+                            var elseIdx = instructions.length;
+                            instructions.push([
+                                ShaderPreprocessorDirective.Else,
+                                -1
+                            ]);
+                            stack.push(elseIdx);
+                            ShaderInstructionEncoder._backfillJump(instructions[prevIdx], instructions.length);
+                            var cond1 = ShaderInstructionEncoder._parseCondition(rest);
+                            var idx3 = instructions.length;
+                            ShaderInstructionEncoder._pushConditionInstruction(instructions, cond1);
+                            stack.push(idx3);
+                            break;
+                        }
+                    case "else":
+                        {
+                            var stack1 = backfillStack[backfillStack.length - 1];
+                            var prevIdx1 = stack1[stack1.length - 1];
+                            var elseIdx1 = instructions.length;
+                            instructions.push([
+                                ShaderPreprocessorDirective.Else,
+                                -1
+                            ]);
+                            stack1.push(elseIdx1);
+                            ShaderInstructionEncoder._backfillJump(instructions[prevIdx1], instructions.length);
+                            break;
+                        }
+                    case "endif":
+                        {
+                            var endifIdx = instructions.length;
+                            instructions.push([
+                                ShaderPreprocessorDirective.Endif
+                            ]);
+                            var stack2 = backfillStack.pop();
+                            if (stack2) {
+                                var afterEndif = endifIdx + 1;
+                                for(var j = 0; j < stack2.length; j++){
+                                    var inst = instructions[stack2[j]];
+                                    if (inst[0] === ShaderPreprocessorDirective.Else) {
+                                        inst[1] = afterEndif;
+                                    } else {
+                                        ShaderInstructionEncoder._backfillJump(inst, afterEndif, true);
+                                    }
                                 }
-                                this.advance(1);
                             }
-                            lexeme += " "; // Replace comment with space
-                            continue;
+                            break;
+                        }
+                    case "define":
+                        {
+                            var funcMatch = ShaderInstructionEncoder._FUNC_MACRO_RE.exec(rest);
+                            if (funcMatch) {
+                                var params = funcMatch[2].split(",").map(function(p) {
+                                    return p.trim();
+                                }).filter(function(p) {
+                                    return p.length > 0;
+                                });
+                                instructions.push([
+                                    ShaderPreprocessorDirective.DefineFunc,
+                                    funcMatch[1],
+                                    params,
+                                    ShaderInstructionEncoder._stripLineComment(funcMatch[3].trim())
+                                ]);
+                            } else {
+                                var spaceIdx = rest.indexOf(" ");
+                                if (spaceIdx === -1) {
+                                    instructions.push([
+                                        ShaderPreprocessorDirective.Define,
+                                        rest
+                                    ]);
+                                } else {
+                                    instructions.push([
+                                        ShaderPreprocessorDirective.DefineVal,
+                                        rest.substring(0, spaceIdx),
+                                        ShaderInstructionEncoder._stripLineComment(rest.substring(spaceIdx + 1).trim())
+                                    ]);
+                                }
+                            }
+                            break;
+                        }
+                    case "undef":
+                        {
+                            instructions.push([
+                                ShaderPreprocessorDirective.Undef,
+                                rest
+                            ]);
+                            break;
                         }
-                    }
                 }
-                // Accumulate useful character
-                lexeme += source[this._currentIndex];
-                this.advance(1);
-            }
-            if (lexeme === "") {
-                return null;
             }
-            var valueToken = BaseToken.pool.get();
-            valueToken.set(MacroParserToken.line_remain, lexeme, ShaderLab.createRange(start, this.getShaderPosition(0)));
-            return valueToken;
+            return instructions;
         };
-        MacroParserLexer._isPpCharacters = function _isPpCharacters(charCode) {
-            return charCode === 35 || // #
-            BaseLexer.isAlnum(charCode) // _, A-Z, a-z, 0-9
-            ;
+        ShaderInstructionEncoder._pushConditionInstruction = function _pushConditionInstruction(instructions, cond) {
+            if (cond.t === "def") {
+                instructions.push([
+                    ShaderPreprocessorDirective.IfDef,
+                    cond.m,
+                    -1
+                ]);
+            } else if (cond.t === "ndef") {
+                instructions.push([
+                    ShaderPreprocessorDirective.IfNdef,
+                    cond.m,
+                    -1
+                ]);
+            } else if (cond.t === "cmp") {
+                instructions.push([
+                    ShaderPreprocessorDirective.IfCmp,
+                    cond.m,
+                    cond.op,
+                    cond.v,
+                    -1
+                ]);
+            } else {
+                instructions.push([
+                    ShaderPreprocessorDirective.IfExpr,
+                    cond,
+                    -1
+                ]);
+            }
         };
-        return MacroParserLexer;
-    }(BaseLexer);
-    MacroParserLexer._lexemeTable = {
-        "#define": MacroParserKeyword.define,
-        "#undef": MacroParserKeyword.undef,
-        "#if": MacroParserKeyword.if,
-        "#ifdef": MacroParserKeyword.ifdef,
-        "#ifndef": MacroParserKeyword.ifndef,
-        "#else": MacroParserKeyword.else,
-        "#elif": MacroParserKeyword.elif,
-        "#endif": MacroParserKeyword.endif,
-        defined: MacroParserKeyword.defined
-    };
-
-    var PpUtils = /*#__PURE__*/ function() {
-        function PpUtils() {}
-        PpUtils.expand = function expand(segments, source) {
-            var ret = [];
-            var startIdx = 0;
-            var generatedIdx = 0;
-            for(var _iterator = _create_for_of_iterator_helper_loose(segments), _step; !(_step = _iterator()).done;){
-                var seg = _step.value;
-                var originSlice = source.slice(startIdx, seg.rangeInBlock.start.index);
-                ret.push(originSlice, seg.replace);
-                var generatedIdxEnd = generatedIdx + originSlice.length + seg.replace.length;
-                startIdx = seg.rangeInBlock.end.index;
-                generatedIdx = generatedIdxEnd;
-            }
-            ret.push(source.slice(startIdx));
-            var result = ret.join("");
-            // Replace multiple consecutive newlines with a single newline to clean up the output
-            return result.replace(/\n\s*\n+/g, "\n");
-        };
-        return PpUtils;
-    }();
-
-    /** @internal */ var MacroParser = /*#__PURE__*/ function() {
-        function MacroParser() {}
-        MacroParser.parse = function parse(source, macros) {
-            MacroParser._reset();
-            for(var _iterator = _create_for_of_iterator_helper_loose(macros), _step; !(_step = _iterator()).done;){
-                var macro = _step.value;
-                MacroParser._addPredefinedMacro(macro.name, macro.value);
-            }
-            this.lexer = new MacroParserLexer(source);
-            return MacroParser._parseDirectives(this.lexer);
-        };
-        MacroParser._reset = function _reset() {
-            this._expandSegmentsStack.length = 0;
-            this._expandSegmentsStack.push([]);
-            this._definedMacros.clear();
-            this._addPredefinedMacro("GL_ES");
-        };
-        MacroParser._addPredefinedMacro = function _addPredefinedMacro(macro, value) {
-            var token = BaseToken.pool.get();
-            token.set(MacroParserToken.id, macro);
-            var macroBody;
-            if (value != undefined) {
-                macroBody = BaseToken.pool.get();
-                macroBody.set(MacroParserToken.id, value);
-            }
-            this._definedMacros.set(macro, new MacroDefine(token, macroBody));
-        };
-        MacroParser._parseDirectives = function _parseDirectives(lexer) {
-            var directive;
-            while(directive = lexer.scanToken()){
-                switch(directive.type){
-                    case MacroParserToken.id:
-                        this._parseMacro(lexer, directive);
-                        break;
-                    case MacroParserKeyword.define:
-                        this._parseDefine(lexer);
-                        break;
-                    case MacroParserKeyword.undef:
-                        this._parseUndef(lexer);
-                        break;
-                    case MacroParserKeyword.if:
-                        this._parseIfDirective(lexer, MacroParserKeyword.if);
-                        break;
-                    case MacroParserKeyword.ifndef:
-                        this._parseIfDirective(lexer, MacroParserKeyword.ifndef);
-                        break;
-                    case MacroParserKeyword.ifdef:
-                        this._parseIfDirective(lexer, MacroParserKeyword.ifdef);
+        ShaderInstructionEncoder._findDirectiveStart = function _findDirectiveStart(source, from, length) {
+            var i = from;
+            while(i < length){
+                var j = i;
+                while(j < length){
+                    var c = source.charCodeAt(j);
+                    if (c === 32 /* space */  || c === 9 /* tab */ ) {
+                        j++;
+                    } else {
                         break;
+                    }
                 }
+                if (j < length && source.charCodeAt(j) === 35 /* '#' */ ) return i;
+                var nl = source.indexOf("\n", i);
+                if (nl === -1) break;
+                i = nl + 1;
             }
-            return PpUtils.expand(this._getExpandSegments(), lexer.source, lexer.sourceMap);
-        };
-        MacroParser._getExpandSegments = function _getExpandSegments() {
-            return this._expandSegmentsStack[this._expandSegmentsStack.length - 1];
+            return -1;
         };
-        MacroParser._reportError = function _reportError(loc, message, source, file) {
-            ShaderLabUtils.createGSError(message, GSErrorName$1.PreprocessorError, source, loc, file);
-        };
-        MacroParser._parseIfDirective = function _parseIfDirective(lexer, directiveType) {
-            var directiveLength = directiveType === MacroParserKeyword.if ? 3 : directiveType === MacroParserKeyword.ifdef ? 6 : 7; // #if = 3,  #ifdef = 6, #ifndef = 7
-            var start = lexer.currentIndex - directiveLength;
-            var skipMacro = false;
-            var shouldInclude;
-            if (directiveType === MacroParserKeyword.if) {
-                shouldInclude = this._parseConstantExpression(lexer);
-            } else {
-                var macroToken = lexer.scanWord();
-                var lexeme = macroToken.lexeme;
-                if (lexeme.startsWith("GL_")) {
-                    skipMacro = true;
-                } else {
-                    var defined = this._definedMacros.get(lexeme);
-                    shouldInclude = directiveType === MacroParserKeyword.ifdef ? !!defined : !defined;
-                }
-            }
-            lexer.skipSpace(true);
-            var _lexer_scanMacroBranchBody = lexer.scanMacroBranchBody(), body = _lexer_scanMacroBranchBody.body, nextDirective = _lexer_scanMacroBranchBody.nextDirective;
-            if (skipMacro) return;
-            if (shouldInclude) {
-                var end = nextDirective.type === MacroParserKeyword.endif ? lexer.getShaderPosition(0) : lexer.scanRemainMacro();
-                var expanded = this._expandMacroChunk(body.lexeme, body.location, lexer);
-                this._addContentReplace(lexer.file, ShaderLab.createPosition(start), end, expanded.content, lexer.blockRange, expanded.sourceMap);
+        ShaderInstructionEncoder._pushText = function _pushText(instructions, source, from, to) {
+            if (from >= to) return;
+            var last = instructions.length > 0 ? instructions[instructions.length - 1] : null;
+            if (last && last[0] === ShaderPreprocessorDirective.Text) {
+                last[1] += source.substring(from, to);
             } else {
-                this._addEmptyReplace(lexer, start);
-                this._processConditionalDirective(nextDirective.type, lexer);
+                instructions.push([
+                    ShaderPreprocessorDirective.Text,
+                    source.substring(from, to)
+                ]);
             }
         };
-        MacroParser._processConditionalDirective = function _processConditionalDirective(directive, scanner) {
-            if (directive === MacroParserKeyword.endif) {
-                return;
+        /**
+       * Backfill jump offset of an IF/ELIF instruction.
+       * When onlyPlaceholder is true, only backfill if the current value is still -1
+       */ ShaderInstructionEncoder._backfillJump = function _backfillJump(inst, target, onlyPlaceholder) {
+            if (onlyPlaceholder === void 0) onlyPlaceholder = false;
+            var directive = inst[0];
+            if (directive === ShaderPreprocessorDirective.IfDef || directive === ShaderPreprocessorDirective.IfNdef) {
+                if (!onlyPlaceholder || inst[2] === -1) inst[2] = target;
+            } else if (directive === ShaderPreprocessorDirective.IfCmp) {
+                if (!onlyPlaceholder || inst[4] === -1) inst[4] = target;
+            } else if (directive === ShaderPreprocessorDirective.IfExpr) {
+                if (!onlyPlaceholder || inst[2] === -1) inst[2] = target;
+            }
+        };
+        ShaderInstructionEncoder._stripLineComment = function _stripLineComment(s) {
+            var idx = s.indexOf("//");
+            return idx >= 0 ? s.substring(0, idx).trimEnd() : s;
+        };
+        ShaderInstructionEncoder._parseCondition = function _parseCondition(expr) {
+            var ctx = {
+                s: expr.trim(),
+                i: 0
+            };
+            return ShaderInstructionEncoder._parseOr(ctx);
+        };
+        ShaderInstructionEncoder._skipWs = function _skipWs(ctx) {
+            while(ctx.i < ctx.s.length && (ctx.s.charCodeAt(ctx.i) === 32 /* space */  || ctx.s.charCodeAt(ctx.i) === 9))ctx.i++;
+        };
+        ShaderInstructionEncoder._parseOr = function _parseOr(ctx) {
+            var left = ShaderInstructionEncoder._parseAnd(ctx);
+            ShaderInstructionEncoder._skipWs(ctx);
+            while(ctx.i < ctx.s.length - 1 && ctx.s.charCodeAt(ctx.i) === 124 /* '|' */  && ctx.s.charCodeAt(ctx.i + 1) === 124 /* '|' */ ){
+                ctx.i += 2;
+                ShaderInstructionEncoder._skipWs(ctx);
+                left = {
+                    t: "or",
+                    l: left,
+                    r: ShaderInstructionEncoder._parseAnd(ctx)
+                };
+                ShaderInstructionEncoder._skipWs(ctx);
+            }
+            return left;
+        };
+        ShaderInstructionEncoder._parseAnd = function _parseAnd(ctx) {
+            var left = ShaderInstructionEncoder._parseUnary(ctx);
+            ShaderInstructionEncoder._skipWs(ctx);
+            while(ctx.i < ctx.s.length - 1 && ctx.s.charCodeAt(ctx.i) === 38 /* '&' */  && ctx.s.charCodeAt(ctx.i + 1) === 38 /* '&' */ ){
+                ctx.i += 2;
+                ShaderInstructionEncoder._skipWs(ctx);
+                left = {
+                    t: "and",
+                    l: left,
+                    r: ShaderInstructionEncoder._parseUnary(ctx)
+                };
+                ShaderInstructionEncoder._skipWs(ctx);
+            }
+            return left;
+        };
+        ShaderInstructionEncoder._parseUnary = function _parseUnary(ctx) {
+            ShaderInstructionEncoder._skipWs(ctx);
+            if (ctx.s.charCodeAt(ctx.i) === 33 /* '!' */ ) {
+                ctx.i++;
+                ShaderInstructionEncoder._skipWs(ctx);
+                return {
+                    t: "not",
+                    c: ShaderInstructionEncoder._parsePrimary(ctx)
+                };
             }
-            var start = scanner.currentIndex;
-            if (directive === MacroParserKeyword.else) {
-                var body = scanner.scanMacroBranchBody().body;
-                var expanded = this._expandMacroChunk(body.lexeme, body.location, scanner);
-                this._addContentReplace(scanner.file, ShaderLab.createPosition(start), scanner.getShaderPosition(0), expanded.content, scanner.blockRange, expanded.sourceMap);
-            } else if (directive === MacroParserKeyword.elif) {
-                var constantExpr = this._parseConstantExpression(scanner);
-                var _scanner_scanMacroBranchBody = scanner.scanMacroBranchBody(), body1 = _scanner_scanMacroBranchBody.body, nextDirective = _scanner_scanMacroBranchBody.nextDirective;
-                if (constantExpr) {
-                    var end = nextDirective.type === MacroParserKeyword.endif ? scanner.currentIndex : scanner.scanRemainMacro().index;
-                    var expanded1 = this._expandMacroChunk(body1.lexeme, body1.location, scanner);
-                    this._addContentReplace(scanner.file, ShaderLab.createPosition(start), ShaderLab.createPosition(end), expanded1.content, scanner.blockRange, expanded1.sourceMap);
-                } else {
-                    this._addContentReplace(scanner.file, ShaderLab.createPosition(start), ShaderLab.createPosition(scanner.currentIndex), "", scanner.blockRange);
-                    this._processConditionalDirective(nextDirective.type, scanner);
-                }
-            }
-        };
-        MacroParser._parseConstantExpression = function _parseConstantExpression(scanner) {
-            scanner.skipSpace(true);
-            return this._parseLogicalOrExpression(scanner);
-        };
-        MacroParser._parseLogicalOrExpression = function _parseLogicalOrExpression(scanner) {
-            var operand1 = this._parseLogicalAndExpression(scanner);
-            var operator = scanner.peek(2);
-            if (operator && operator === "||") {
-                scanner.advance(2);
-                scanner.skipSpace(false);
-                var operand2 = this._parseLogicalOrExpression(scanner);
-                return operand1 || operand2;
-            }
-            return operand1;
-        };
-        MacroParser._parseLogicalAndExpression = function _parseLogicalAndExpression(scanner) {
-            var operand1 = this._parseEqualityExpression(scanner);
-            var operator = scanner.peek(2);
-            if (operator && operator === "&&") {
-                scanner.advance(2);
-                scanner.skipSpace(false);
-                var operand2 = this._parseLogicalAndExpression(scanner);
-                return operand1 && operand2;
-            }
-            return operand1;
-        };
-        MacroParser._parseEqualityExpression = function _parseEqualityExpression(scanner) {
-            var operand1 = this._parseRelationalExpression(scanner);
-            var operator = scanner.peek(2);
-            if (operator && [
-                "==",
-                "!="
-            ].includes(operator)) {
-                scanner.advance(2);
-                scanner.skipSpace(false);
-                var operand2 = this._parseEqualityExpression(scanner);
-                switch(operator){
-                    case "==":
-                        return operand1 === operand2;
-                    case "!=":
-                        return operand1 !== operand2;
-                }
-            }
-            return operand1;
-        };
-        MacroParser._parseRelationalExpression = function _parseRelationalExpression(scanner) {
-            var operand1 = this._parseShiftExpression(scanner);
-            var operator = scanner.peek(2);
-            if (operator[1] !== "=") operator = operator[0];
-            if (operator && [
-                ">",
-                "<",
-                ">=",
-                "<="
-            ].includes(operator)) {
-                var opPos = scanner.getShaderPosition(0);
-                scanner.advance(operator.length);
-                scanner.skipSpace(false);
-                var operand2 = this._parseRelationalExpression(scanner);
-                if ((typeof operand1 === "undefined" ? "undefined" : _type_of(operand1)) !== (typeof operand2 === "undefined" ? "undefined" : _type_of(operand2)) && typeof operand1 !== "number") {
-                    this._reportError(opPos, "invalid operator in relation expression.", scanner.source, scanner.file);
-                    return;
-                }
-                switch(operator){
-                    case ">":
-                        return operand1 > operand2;
-                    case "<":
-                        return operand1 < operand2;
-                    case ">=":
-                        return operand1 >= operand2;
-                    case "<=":
-                        return operand1 <= operand2;
-                }
-            }
-            return operand1;
-        };
-        MacroParser._parseShiftExpression = function _parseShiftExpression(scanner) {
-            var operand1 = this._parseAdditiveExpression(scanner);
-            var operator = scanner.peek(2);
-            if (operator && [
-                ">>",
-                "<<"
-            ].includes(operator)) {
-                var opPos = scanner.getShaderPosition(0);
-                scanner.advance(2);
-                scanner.skipSpace(false);
-                var operand2 = this._parseShiftExpression(scanner);
-                if ((typeof operand1 === "undefined" ? "undefined" : _type_of(operand1)) !== (typeof operand2 === "undefined" ? "undefined" : _type_of(operand2)) && typeof operand1 !== "number") {
-                    this._reportError(opPos, "invalid operator in shift expression.", scanner.source, scanner.file);
-                    return;
-                }
-                switch(operator){
-                    case ">>":
-                        return operand1 >> operand2;
-                    case "<<":
-                        return operand1 << operand2;
-                }
-            }
-            return operand1;
-        };
-        MacroParser._parseAdditiveExpression = function _parseAdditiveExpression(scanner) {
-            var operand1 = this._parseMulticativeExpression(scanner);
-            if ([
-                ">",
-                "<"
-            ].includes(scanner.getCurChar())) {
-                var opPos = scanner.getShaderPosition(0);
-                scanner.advance(1);
-                var operator = scanner.getCurChar();
-                scanner.skipSpace(false);
-                var operand2 = this._parseAdditiveExpression(scanner);
-                if ((typeof operand1 === "undefined" ? "undefined" : _type_of(operand1)) !== (typeof operand2 === "undefined" ? "undefined" : _type_of(operand2)) && typeof operand1 !== "number") {
-                    this._reportError(opPos, "invalid operator.", scanner.source, scanner.file);
-                    return false;
-                }
-                switch(operator){
-                    case "+":
-                        return operand1 + operand2;
-                    case "-":
-                        return operand1 - operand2;
-                }
-            }
-            return operand1;
-        };
-        MacroParser._parseMulticativeExpression = function _parseMulticativeExpression(scanner) {
-            var operand1 = this._parseUnaryExpression(scanner);
-            scanner.skipSpace(false);
-            if ([
-                "*",
-                "/",
-                "%"
-            ].includes(scanner.getCurChar())) {
-                var opPos = scanner.getShaderPosition(0);
-                var operator = scanner.getCurChar();
-                scanner.skipSpace(false);
-                var operand2 = this._parseMulticativeExpression(scanner);
-                if ((typeof operand1 === "undefined" ? "undefined" : _type_of(operand1)) !== (typeof operand2 === "undefined" ? "undefined" : _type_of(operand2)) && typeof operand1 !== "number") {
-                    this._reportError(opPos, "invalid operator.", scanner.source, scanner.file);
-                    return;
-                }
-                switch(operator){
-                    case "*":
-                        return operand1 * operand2;
-                    case "/":
-                        return operand1 / operand2;
-                    case "%":
-                        return operand1 % operand2;
-                }
-            }
-            return operand1;
-        };
-        MacroParser._parseUnaryExpression = function _parseUnaryExpression(scanner) {
-            var operator = scanner.getCurChar();
-            if ([
-                "+",
-                "-",
-                "!"
-            ].includes(operator)) {
-                var opPos = scanner.getShaderPosition(0);
-                scanner.advance(1);
-                scanner.skipSpace(false);
-                var parenExpr = this._parseParenthesisExpression(scanner);
-                if (operator === "!" && typeof parenExpr !== "boolean" || operator !== "!" && typeof parenExpr !== "number") {
-                    this._reportError(opPos, "invalid operator.", scanner.source, scanner.file);
-                }
-                switch(operator){
-                    case "+":
-                        return parenExpr;
-                    case "-":
-                        return -parenExpr;
-                    case "!":
-                        return !parenExpr;
-                }
-            }
-            return this._parseParenthesisExpression(scanner);
-        };
-        MacroParser._parseParenthesisExpression = function _parseParenthesisExpression(scanner) {
-            if (scanner.getCurChar() === "(") {
-                scanner.advance(1);
-                scanner.skipSpace(false);
-                var ret = this._parseConstantExpression(scanner);
-                scanner.scanToChar(")");
-                scanner.advance(1);
-                return ret;
-            }
-            return this._parseConstant(scanner);
-        };
-        MacroParser._parseConstant = function _parseConstant(scanner) {
-            if (BaseLexer.isAlpha(scanner.getCurCharCode())) {
-                var id = scanner.scanWord();
-                if (id.type === MacroParserKeyword.defined) {
-                    var withParen = scanner.peekNonSpace() === "(";
-                    var macro = scanner.scanWord();
-                    if (withParen) {
-                        scanner.scanToChar(")");
-                        scanner.advance(1);
-                    }
-                    return !!this._definedMacros.get(macro.lexeme);
-                } else {
-                    var macro1 = this._definedMacros.get(id.lexeme);
-                    if (!macro1) {
-                        return false;
-                    }
-                    if (!macro1.body) {
-                        return true;
-                    }
-                    if (macro1.isFunction) {
-                        this._reportError(id.location, "invalid function macro usage", scanner.source, scanner.file);
-                    }
-                    var value = Number(macro1.body.lexeme);
-                    if (!Number.isInteger(value)) {
-                        this._reportError(id.location, "invalid const macro: " + id.lexeme, scanner.source, scanner.file);
-                    }
-                    return value;
-                }
-            } else if (BaseLexer.isDigit(scanner.getCurCharCode())) {
-                var integer = scanner.scanInteger();
-                return Number(integer.lexeme);
-            } else {
-                this._reportError(scanner.getShaderPosition(0), "invalid token: " + scanner.getCurChar(), scanner.source, scanner.file);
+            return ShaderInstructionEncoder._parsePrimary(ctx);
+        };
+        ShaderInstructionEncoder._parsePrimary = function _parsePrimary(ctx) {
+            ShaderInstructionEncoder._skipWs(ctx);
+            var s = ctx.s;
+            // Parenthesized expression
+            if (s.charCodeAt(ctx.i) === 40 /* '(' */ ) {
+                ctx.i++;
+                ShaderInstructionEncoder._skipWs(ctx);
+                var inner = ShaderInstructionEncoder._parseOr(ctx);
+                ShaderInstructionEncoder._skipWs(ctx);
+                if (s.charCodeAt(ctx.i) === 41 /* ')' */ ) ctx.i++;
+                return inner;
+            }
+            // defined(MACRO) or defined MACRO
+            if (s.substring(ctx.i, ctx.i + 7) === "defined") {
+                ctx.i += 7;
+                ShaderInstructionEncoder._skipWs(ctx);
+                var hasParen = s.charCodeAt(ctx.i) === 40; /* '(' */ 
+                if (hasParen) ctx.i++;
+                ShaderInstructionEncoder._skipWs(ctx);
+                var name = ShaderInstructionEncoder._scanIdentifier(ctx);
+                ShaderInstructionEncoder._skipWs(ctx);
+                if (hasParen && s.charCodeAt(ctx.i) === 41 /* ')' */ ) ctx.i++;
+                return {
+                    t: "def",
+                    m: name
+                };
             }
-        };
-        MacroParser._parseMacroFunctionArgs = function _parseMacroFunctionArgs(source, startIndex, macroName) {
-            var length = source.length;
-            var i = startIndex + macroName.length;
-            // Find opening parenthesis
-            while(i < length && source.charCodeAt(i) !== 40)i++;
-            // Parse function arguments
-            var args = [];
-            var level = 1;
-            var argStart = i + 1;
-            var k = argStart;
-            while(k < length && level > 0){
-                var charCode = source.charCodeAt(k);
-                if (charCode === 40) {
-                    level++;
-                } else if (charCode === 41) {
-                    if (--level === 0) {
-                        var arg = source.substring(argStart, k).trim();
-                        if (arg.length > 0) args.push(arg);
-                        break;
-                    }
-                } else if (charCode === 44 && level === 1) {
-                    var arg1 = source.substring(argStart, k).trim();
-                    if (arg1.length > 0) args.push(arg1);
-                    argStart = k + 1;
+            // Numeric literal
+            if (ctx.i < s.length && ShaderInstructionEncoder._isDigit(s.charCodeAt(ctx.i))) {
+                var lhsNum = ShaderInstructionEncoder._scanNumber(ctx);
+                ShaderInstructionEncoder._skipWs(ctx);
+                var op = ShaderInstructionEncoder._scanOp(ctx);
+                if (op) {
+                    ShaderInstructionEncoder._skipWs(ctx);
+                    return {
+                        t: "bool",
+                        v: ShaderInstructionEncoder._evalNumOp(lhsNum, op, ShaderInstructionEncoder._scanNumber(ctx))
+                    };
                 }
-                k++;
+                return {
+                    t: "bool",
+                    v: lhsNum !== 0
+                };
             }
-            return {
-                args: args,
-                endIndex: k + 1
+            // Identifier — comparison or defined check
+            var name1 = ShaderInstructionEncoder._scanIdentifier(ctx);
+            if (!name1) return {
+                t: "bool",
+                v: false
             };
-        };
-        MacroParser._expandMacroBody = function _expandMacroBody(body) {
-            var visitedMacros = this._expandVisitedMacros;
-            var currentVersionId = ++this._expandVersionId;
-            var expandedBody = body;
-            var hasExpansion = true;
-            while(hasExpansion){
-                hasExpansion = false;
-                var length = expandedBody.length;
-                var i = 0;
-                while(i < length){
-                    var charCode = expandedBody.charCodeAt(i);
-                    if (!BaseLexer.isAlpha(charCode)) {
-                        i++;
-                        continue;
-                    }
-                    var start = i;
-                    while(i < length && BaseLexer.isAlnum(expandedBody.charCodeAt(i))){
-                        i++;
-                    }
-                    var macroName = expandedBody.substring(start, i);
-                    var macro = this._definedMacros.get(macroName);
-                    if (!macro || visitedMacros[macroName] === currentVersionId) {
-                        continue;
-                    }
-                    // Prevent circular references
-                    visitedMacros[macroName] = currentVersionId;
-                    var replacement = void 0;
-                    var endIndex = void 0;
-                    if (!macro.isFunction) {
-                        var _macro_body;
-                        var _macro_body_lexeme;
-                        replacement = (_macro_body_lexeme = (_macro_body = macro.body) == null ? void 0 : _macro_body.lexeme) != null ? _macro_body_lexeme : "";
-                        endIndex = i;
-                    } else {
-                        var _this__parseMacroFunctionArgs = this._parseMacroFunctionArgs(expandedBody, start, macroName), args = _this__parseMacroFunctionArgs.args, newEndIndex = _this__parseMacroFunctionArgs.endIndex;
-                        replacement = macro.expandFunctionBody(args);
-                        endIndex = newEndIndex;
-                    }
-                    expandedBody = expandedBody.substring(0, start) + replacement + expandedBody.substring(endIndex);
-                    hasExpansion = true;
-                    break;
-                }
-            }
-            return expandedBody;
-        };
-        MacroParser._expandMacroChunk = function _expandMacroChunk(chunk, loc, scannerOrFile) {
-            this._expandSegmentsStack.push([]);
-            var scanner;
-            if (typeof scannerOrFile === "string") {
-                scanner = new MacroParserLexer(chunk, scannerOrFile);
-            } else {
-                scanner = new MacroParserLexer(chunk, scannerOrFile.file, loc);
+            ShaderInstructionEncoder._skipWs(ctx);
+            var op1 = ShaderInstructionEncoder._scanOp(ctx);
+            if (op1) {
+                ShaderInstructionEncoder._skipWs(ctx);
+                return {
+                    t: "cmp",
+                    m: name1,
+                    op: op1,
+                    v: ShaderInstructionEncoder._scanNumber(ctx)
+                };
             }
-            var ret = this._parseDirectives(scanner);
-            this._expandSegmentsStack.pop();
             return {
-                content: ret
+                t: "def",
+                m: name1
             };
         };
-        MacroParser._addEmptyReplace = function _addEmptyReplace(lexer, start) {
-            this._addContentReplace(lexer.file, ShaderLab.createPosition(start), lexer.getShaderPosition(0), "", lexer.blockRange);
-        };
-        MacroParser._addContentReplace = function _addContentReplace(sourceFile, start, end, content, sourceRange, sourceMap) {
-            var range = ShaderLab.createRange(start, end);
-            this._getExpandSegments().push({
-                rangeInBlock: range,
-                replace: content
-            });
-        };
-        MacroParser._parseDefine = function _parseDefine(lexer) {
-            var start = lexer.getShaderPosition(7);
-            var macroName = lexer.scanWord();
-            var lexeme = macroName.lexeme, location = macroName.location;
-            var end = location.end;
-            if (this._definedMacros.get(lexeme) && lexeme.startsWith("GL_")) {
-                this._reportError(location, "Redefined macro: " + lexeme, lexer.source, lexer.file);
-            }
-            var macroArgs;
-            if (lexer.getCurChar() === "(") {
-                macroArgs = lexer.scanWordsUntilTerminator(")");
-                end = lexer.getShaderPosition(0);
-            }
-            var macroBody = lexer.scanMacroBody();
-            var range = ShaderLab.createRange(start, end);
-            var macroDefine = new MacroDefine(macroName, macroBody, range, macroArgs);
-            this._definedMacros.set(lexeme, macroDefine);
-            this._addContentReplace(lexer.file, start, lexer.getShaderPosition(0), "", lexer.blockRange);
-        };
-        MacroParser._parseUndef = function _parseUndef(lexer) {
-            var start = lexer.getShaderPosition(6);
-            var macroName = lexer.scanWord();
-            this._definedMacros.delete(macroName.lexeme);
-            this._addContentReplace(lexer.file, start, lexer.getShaderPosition(0), "", lexer.blockRange);
-        };
-        MacroParser._parseMacro = function _parseMacro(lexer, token) {
-            var macro = this._definedMacros.get(token.lexeme);
-            if (macro) {
-                var location = token.location;
-                if (macro.isFunction) {
-                    var _this__parseMacroFunctionArgs = this._parseMacroFunctionArgs(lexer.source, location.start.index, token.lexeme), args = _this__parseMacroFunctionArgs.args, endIndex = _this__parseMacroFunctionArgs.endIndex;
-                    var macroBodyExpanded = macro.expandFunctionBody(args);
-                    var expandedContent = this._expandMacroBody(macroBodyExpanded);
-                    var remainingLength = endIndex - location.end.index;
-                    lexer.advance(remainingLength);
-                    this._addContentReplace(lexer.file, location.start, lexer.getShaderPosition(0), expandedContent, lexer.blockRange);
-                } else {
-                    var _macro_body;
-                    var _macro_body_lexeme;
-                    var macroContent = (_macro_body_lexeme = (_macro_body = macro.body) == null ? void 0 : _macro_body.lexeme) != null ? _macro_body_lexeme : "";
-                    var expandedContent1 = this._expandMacroBody(macroContent);
-                    this._addContentReplace(lexer.file, location.start, location.end, expandedContent1, lexer.blockRange);
-                }
+        ShaderInstructionEncoder._isDigit = function _isDigit(charCode) {
+            return charCode >= 48 /* '0' */  && charCode <= 57 /* '9' */ ;
+        };
+        ShaderInstructionEncoder._isAlnum = function _isAlnum(charCode) {
+            return charCode >= 65 /* 'A' */  && charCode <= 90 || charCode >= 97 /* 'a' */  && charCode <= 122 || charCode >= 48 /* '0' */  && charCode <= 57 || charCode === 95 /* '_' */ ;
+        };
+        ShaderInstructionEncoder._scanIdentifier = function _scanIdentifier(ctx) {
+            var start = ctx.i;
+            while(ctx.i < ctx.s.length && ShaderInstructionEncoder._isAlnum(ctx.s.charCodeAt(ctx.i)))ctx.i++;
+            return ctx.s.substring(start, ctx.i);
+        };
+        ShaderInstructionEncoder._scanNumber = function _scanNumber(ctx) {
+            var start = ctx.i;
+            if (ctx.s.charCodeAt(ctx.i) === 45 /* '-' */ ) ctx.i++;
+            while(ctx.i < ctx.s.length && (ShaderInstructionEncoder._isDigit(ctx.s.charCodeAt(ctx.i)) || ctx.s.charCodeAt(ctx.i) === 46))ctx.i++;
+            return Number(ctx.s.substring(start, ctx.i)) || 0;
+        };
+        ShaderInstructionEncoder._scanOp = function _scanOp(ctx) {
+            var c = ctx.s.charCodeAt(ctx.i);
+            var c2 = ctx.i + 1 < ctx.s.length ? ctx.s.charCodeAt(ctx.i + 1) : 0;
+            if (c === 61 /* '=' */  && c2 === 61 /* '=' */ ) {
+                ctx.i += 2;
+                return "==";
+            }
+            if (c === 33 /* '!' */  && c2 === 61 /* '=' */ ) {
+                ctx.i += 2;
+                return "!=";
+            }
+            if (c === 62 /* '>' */  && c2 === 61 /* '=' */ ) {
+                ctx.i += 2;
+                return ">=";
+            }
+            if (c === 60 /* '<' */  && c2 === 61 /* '=' */ ) {
+                ctx.i += 2;
+                return "<=";
+            }
+            if (c === 62 /* '>' */ ) {
+                ctx.i++;
+                return ">";
+            }
+            if (c === 60 /* '<' */ ) {
+                ctx.i++;
+                return "<";
+            }
+            return "";
+        };
+        ShaderInstructionEncoder._evalNumOp = function _evalNumOp(lhs, op, rhs) {
+            switch(op){
+                case "==":
+                    return lhs === rhs;
+                case "!=":
+                    return lhs !== rhs;
+                case ">":
+                    return lhs > rhs;
+                case "<":
+                    return lhs < rhs;
+                case ">=":
+                    return lhs >= rhs;
+                case "<=":
+                    return lhs <= rhs;
+                default:
+                    return false;
             }
         };
-        return MacroParser;
+        return ShaderInstructionEncoder;
     }();
-    MacroParser._definedMacros = new Map();
-    MacroParser._expandSegmentsStack = [
-        []
-    ];
-    MacroParser._expandVisitedMacros = {};
-    MacroParser._expandVersionId = 1;
+    ShaderInstructionEncoder._DIRECTIVE_RE = /^[ \t]*#[ \t]*(if|ifdef|ifndef|elif|else|endif|define|undef)\b(.*)/;
+    ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
 
     var StateItem = /*#__PURE__*/ function() {
         function StateItem(production, position, lookahead) {
@@ -7307,7 +6919,7 @@
                     traceBackStack.push(nextState);
                     continue;
                 } else {
-                    ShaderLabUtils.createGSError("Unexpected token " + token.lexeme, GSErrorName$1.CompilationError, ShaderLab._processingPassText, token.location);
+                    ShaderLabUtils.createGSError("Unexpected token " + token.lexeme, GSErrorName.CompilationError, ShaderLab._processingPassText, token.location);
                     return null;
                 }
             }
@@ -7498,7 +7110,7 @@
             }
         };
         _proto.createCompileError = function createCompileError(message, location) {
-            return ShaderLabUtils.createGSError(message, GSErrorName$1.CompilationError, this.source, location != null ? location : this.getShaderPosition(0));
+            return ShaderLabUtils.createGSError(message, GSErrorName.CompilationError, this.source, location != null ? location : this.getShaderPosition(0));
         };
         _proto._scanWord = function _scanWord(start) {
             // Scan the complete word first
@@ -7960,7 +7572,7 @@
                         lexer.scanLexeme("=");
                         var entry = lexer.scanToken();
                         if (passSource[token.lexeme]) {
-                            ShaderLabUtils.createGSError("Reassign main entry", GSErrorName$1.CompilationError, lexer.source, lexer.getShaderPosition(0));
+                            ShaderLabUtils.createGSError("Reassign main entry", GSErrorName.CompilationError, lexer.source, lexer.getShaderPosition(0));
                         }
                         var key = token.type === Keyword.GSVertexShader ? "vertexEntry" : "fragmentEntry";
                         passSource[key] = entry.lexeme;
@@ -8072,13 +7684,69 @@
             engine.Logger.info("[Task - CodeGen] cost time: " + (performance.now() - codeGenStartTime) + "ms");
             engine.Logger.info("[Task - Total compilation] cost time: " + (performance.now() - totalStartTime) + "ms");
             ShaderLab._processingPassText = undefined;
+            if (ret) {
+                // Always parse instructions for the compiled GLSL
+                ret.vertexShaderInstructions = ShaderInstructionEncoder.parse(ret.vertex);
+                ret.fragmentShaderInstructions = ShaderInstructionEncoder.parse(ret.fragment);
+            }
             return ret;
         };
-        _proto._parseMacros = function _parseMacros(content, macros) {
-            var startTime = performance.now();
-            var parsedContent = MacroParser.parse(content, macros);
-            engine.Logger.info("[Task -  parse macros] cost time: " + (performance.now() - startTime) + "ms");
-            return parsedContent;
+        _proto._precompile = function _precompile(sourceCode, platformTarget, basePath) {
+            var _this = this;
+            var shaderSource = this._parseShaderSource(sourceCode);
+            var subShaders = shaderSource.subShaders.map(function(sub) {
+                return {
+                    name: sub.name,
+                    tags: sub.tags,
+                    passes: sub.passes.map(function(pass) {
+                        if (pass.isUsePass) {
+                            return {
+                                name: pass.name,
+                                isUsePass: true,
+                                tags: pass.tags,
+                                renderStates: _this._serializeRenderStates(pass.renderStates)
+                            };
+                        }
+                        var programSource = _this._parseShaderPass(pass.contents, pass.vertexEntry, pass.fragmentEntry, platformTarget, basePath);
+                        if (!programSource) {
+                            throw new Error('Shader pass "' + shaderSource.name + "." + sub.name + "." + pass.name + '" precompile failed, please check the shader source code.');
+                        }
+                        return {
+                            name: pass.name,
+                            isUsePass: false,
+                            tags: pass.tags,
+                            renderStates: _this._serializeRenderStates(pass.renderStates),
+                            vertexShaderInstructions: programSource.vertexShaderInstructions,
+                            fragmentShaderInstructions: programSource.fragmentShaderInstructions
+                        };
+                    })
+                };
+            });
+            return {
+                name: shaderSource.name,
+                platformTarget: platformTarget,
+                subShaders: subShaders
+            };
+        };
+        _proto._serializeRenderStates = function _serializeRenderStates(renderStates) {
+            var constantMap = {};
+            for(var key in renderStates.constantMap){
+                var value = renderStates.constantMap[key];
+                if (_instanceof(value, engine.Color)) {
+                    constantMap[key] = [
+                        value.r,
+                        value.g,
+                        value.b,
+                        value.a
+                    ];
+                } else {
+                    constantMap[key] = value;
+                }
+            }
+            return {
+                constantMap: constantMap,
+                variableMap: renderStates.variableMap
+            };
         };
         ShaderLab.createPosition = function createPosition(index, line, column) {
             var position = this._shaderPositionPool.get();
@@ -8097,12 +7765,12 @@
     ShaderLab._shaderRangePool = ShaderLabUtils.createObjectPool(ShaderRange);
 
     //@ts-ignore
-    var version = "2.0.0-alpha.24";
+    var version = "2.0.0-alpha.26";
     var mode = "Release";
     console.log("Galacean Engine ShaderLab Version: " + version + " | Mode: " + mode);
 
     exports.GSError = GSError;
-    exports.GSErrorName = GSErrorName$1;
+    exports.GSErrorName = GSErrorName;
     exports.ShaderLab = ShaderLab;
     exports.version = version;