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

package/dist/module.js

@@ -1,5 +1,11 @@
 import { ClearableObjectPool, Logger, ShaderPass, ShaderLib, ReturnableObjectPool, Color, RenderStateElementKey, RenderQueueType, CompareFunction, StencilOperation, BlendOperation, BlendFactor, CullMode, ColorWriteMask, ShaderLanguage } from '@galacean/engine';
 
+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;
@@ -20,12 +26,6 @@ function _inherits(subClass, superClass) {
     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];
@@ -1198,7 +1198,7 @@ var GSError = /*#__PURE__*/ function(Error1) {
     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";
@@ -1334,7 +1334,7 @@ var SemanticAnalyzer = /*#__PURE__*/ function() {
         Logger.error(message);
     };
     _proto.reportWarning = function reportWarning(loc, message) {
-        Logger.warn(new GSError(GSErrorName$1.CompilationWarn, message, loc, ShaderLab._processingPassText).toString());
+        Logger.warn(new GSError(GSErrorName.CompilationWarn, message, loc, ShaderLab._processingPassText).toString());
     };
     _create_class(SemanticAnalyzer, [
         {
@@ -3179,7 +3179,7 @@ var ParserUtils = /*#__PURE__*/ function() {
             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;
     };
@@ -3190,7 +3190,7 @@ var ParserUtils = /*#__PURE__*/ function() {
             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;
     };
@@ -3201,7 +3201,7 @@ var ParserUtils = /*#__PURE__*/ function() {
             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;
     };
@@ -4050,7 +4050,7 @@ var GLES300Visitor = /*#__PURE__*/ function(GLESVisitor) {
         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) {
@@ -4621,840 +4621,452 @@ Lexer._lexemeTable = {
     "#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) {
@@ -7303,7 +6915,7 @@ var addTranslationRule = function(sa) {
                 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;
             }
         }
@@ -7494,7 +7106,7 @@ var SourceLexer = /*#__PURE__*/ function(BaseLexer1) {
         }
     };
     _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
@@ -7956,7 +7568,7 @@ SourceLexer._symbolLexemeTable = {
                     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;
@@ -8068,13 +7680,69 @@ var ShaderLab = /*#__PURE__*/ function() {
         Logger.info("[Task - CodeGen] cost time: " + (performance.now() - codeGenStartTime) + "ms");
         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);
-        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, 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();
@@ -8093,9 +7761,9 @@ ShaderLab._shaderPositionPool = ShaderLabUtils.createObjectPool(ShaderPosition);
 ShaderLab._shaderRangePool = ShaderLabUtils.createObjectPool(ShaderRange);
 
 //@ts-ignore
-var version = "2.0.0-alpha.25";
+var version = "2.0.0-alpha.26";
 var mode = "Release";
 console.log("Galacean Engine ShaderLab Version: " + version + " | Mode: " + mode);
 
-export { GSError, GSErrorName$1 as GSErrorName, ShaderLab, version };
+export { GSError, GSErrorName, ShaderLab, version };
 //# sourceMappingURL=module.js.map