@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/gfx/graphics/webGpu/shader/converter/GLSLLexerToken.js

@@ -0,0 +1,388 @@
+export class GLSLLexerToken {
+    constructor(type = TokenType.EOF, literal = "\0") {
+        this.Type = 0;
+        this.Line = 0;
+        this.Colume = 0;
+        this.Literal = "";
+        this.Type = type;
+        this.Literal = literal;
+    }
+    /**
+     * @returns determin the type is same to token
+     */
+    isTypeEqual(type) {
+        return this.Type == type;
+    }
+    /**
+     * @returns determin the value is same
+     */
+    isLiteralEqual(literal) {
+        return this.Literal == literal;
+    }
+    /**
+     * @returns determin it's builtin type
+     */
+    isBuiltinType() {
+        return (this.Type > TokenType.BeginBuiltinType &&
+            this.Type < TokenType.EndBuiltinType);
+    }
+    /**
+     * @returns determin it's a data type
+     */
+    isDataType() {
+        return this.Type == TokenType.IDENT || this.isBuiltinType();
+    }
+    /**
+     * @returns determin it's a operation
+     */
+    isOperation() {
+        return (this.Type > TokenType.BeginOperation && this.Type < TokenType.EndOperation);
+    }
+    /**
+     * @returns determin it's a assign operation
+     */
+    isAssignOperation() {
+        return (this.Type > TokenType.BeginAssignOperation &&
+            this.Type < TokenType.EndAssignOperation);
+    }
+    /**
+     * The priority of the current operator
+     */
+    get nOperationPriorityLevel() {
+        switch (this.Type) {
+            case TokenType.LEFTSAMLL:
+                return 1;
+            case TokenType.RIGHTSAMLL:
+                return 1;
+            case TokenType.DOT:
+                return 2;
+            case TokenType.NOT:
+                return 3;
+            case TokenType.BITNOT:
+                return 3;
+            case TokenType.MUL:
+                return 4;
+            case TokenType.DIV:
+                return 4;
+            case TokenType.ADD:
+                return 5;
+            case TokenType.SUB:
+                return 5;
+            case TokenType.BITSHIFT_L:
+                return 6;
+            case TokenType.BITSHIFT_R:
+                return 6;
+            case TokenType.GREATER:
+                return 7;
+            case TokenType.GREATEREQUAL:
+                return 7;
+            case TokenType.LESS:
+                return 7;
+            case TokenType.LESSEQUAL:
+                return 7;
+            case TokenType.EQUAL:
+                return 8;
+            case TokenType.NOTEQUAL:
+                return 8;
+            case TokenType.BITAND:
+                return 9;
+            case TokenType.BITXOR:
+                return 10;
+            case TokenType.BITOR:
+                return 11;
+            case TokenType.AND:
+                return 12;
+            case TokenType.XOR:
+                return 13;
+            case TokenType.OR:
+                return 14;
+            case TokenType.QUEMARK:
+                return 15;
+            case TokenType.ASSIGN:
+                return 16;
+            case TokenType.ADDASSIGN:
+                return 16;
+            case TokenType.SUBASSIGN:
+                return 16;
+            case TokenType.MULASSIGN:
+                return 16;
+            case TokenType.DIVASSIGN:
+                return 16;
+        }
+        return 99;
+    }
+}
+/**
+ * @internal
+ */
+export var TokenType;
+(function (TokenType) {
+    // end-of-file
+    TokenType[TokenType["EOF"] = 0] = "EOF";
+    // identifier
+    TokenType[TokenType["IDENT"] = 1] = "IDENT";
+    // void
+    TokenType[TokenType["VOID"] = 2] = "VOID";
+    // const
+    TokenType[TokenType["CONST"] = 3] = "CONST";
+    // layout
+    TokenType[TokenType["LAYOUT"] = 4] = "LAYOUT";
+    // precision
+    TokenType[TokenType["PRECISION"] = 5] = "PRECISION";
+    // attribute
+    TokenType[TokenType["ATTRIBUTE"] = 6] = "ATTRIBUTE";
+    // uniform
+    TokenType[TokenType["UNIFORM"] = 7] = "UNIFORM";
+    // varying
+    TokenType[TokenType["VARYING"] = 8] = "VARYING";
+    // invariant
+    TokenType[TokenType["INVARIANT"] = 9] = "INVARIANT";
+    // in
+    TokenType[TokenType["IN"] = 10] = "IN";
+    // out
+    TokenType[TokenType["OUT"] = 11] = "OUT";
+    // inout
+    TokenType[TokenType["INOUT"] = 12] = "INOUT";
+    // if
+    TokenType[TokenType["IF"] = 13] = "IF";
+    // else
+    TokenType[TokenType["ELSE"] = 14] = "ELSE";
+    // for
+    TokenType[TokenType["FOR"] = 15] = "FOR";
+    // while
+    TokenType[TokenType["WHILE"] = 16] = "WHILE";
+    // do
+    TokenType[TokenType["DO"] = 17] = "DO";
+    // break
+    TokenType[TokenType["BREAK"] = 18] = "BREAK";
+    // return
+    TokenType[TokenType["RETURN"] = 19] = "RETURN";
+    // continue
+    TokenType[TokenType["CONTINUE"] = 20] = "CONTINUE";
+    // struct
+    TokenType[TokenType["STRUCT"] = 21] = "STRUCT";
+    // ,
+    TokenType[TokenType["COMMA"] = 22] = "COMMA";
+    // :
+    TokenType[TokenType["COLON"] = 23] = "COLON";
+    // ?
+    TokenType[TokenType["QUEMARK"] = 24] = "QUEMARK";
+    // ;
+    TokenType[TokenType["SEMICOLON"] = 25] = "SEMICOLON";
+    // (
+    TokenType[TokenType["LEFTSAMLL"] = 26] = "LEFTSAMLL";
+    // )
+    TokenType[TokenType["RIGHTSAMLL"] = 27] = "RIGHTSAMLL";
+    // [
+    TokenType[TokenType["LEFTMEDI"] = 28] = "LEFTMEDI";
+    // ]
+    TokenType[TokenType["RIGHTMEDI"] = 29] = "RIGHTMEDI";
+    // {
+    TokenType[TokenType["LEFTBIG"] = 30] = "LEFTBIG";
+    // }
+    TokenType[TokenType["RIGHTBIG"] = 31] = "RIGHTBIG";
+    // Literal value
+    TokenType[TokenType["LITERAL"] = 32] = "LITERAL";
+    // built-in type begin
+    TokenType[TokenType["BeginBuiltinType"] = 33] = "BeginBuiltinType";
+    // built-in type: int
+    TokenType[TokenType["INT"] = 34] = "INT";
+    // built-in type: int[]
+    TokenType[TokenType["INT_ARRAY"] = 35] = "INT_ARRAY";
+    // built-in type: uint
+    TokenType[TokenType["UINT"] = 36] = "UINT";
+    // built-in type: uint[]
+    TokenType[TokenType["UINT_ARRAY"] = 37] = "UINT_ARRAY";
+    // built-in type: bool
+    TokenType[TokenType["BOOL"] = 38] = "BOOL";
+    // built-in type: bool[]
+    TokenType[TokenType["BOOL_ARRAY"] = 39] = "BOOL_ARRAY";
+    // built-in type: float
+    TokenType[TokenType["FLOAT"] = 40] = "FLOAT";
+    // built-in type: float[]
+    TokenType[TokenType["FLOAT_ARRAY"] = 41] = "FLOAT_ARRAY";
+    // built-in type: double
+    TokenType[TokenType["DOUBLE"] = 42] = "DOUBLE";
+    // built-in type: double[]
+    TokenType[TokenType["DOUBLE_ARRAY"] = 43] = "DOUBLE_ARRAY";
+    // built-in type: vec2
+    TokenType[TokenType["VEC2"] = 44] = "VEC2";
+    // built-in type: vec2[]
+    TokenType[TokenType["VEC2_ARRAY"] = 45] = "VEC2_ARRAY";
+    // built-in type: vec3
+    TokenType[TokenType["VEC3"] = 46] = "VEC3";
+    // built-in type: vec3[]
+    TokenType[TokenType["VEC3_ARRAY"] = 47] = "VEC3_ARRAY";
+    // built-in type: vec4
+    TokenType[TokenType["VEC4"] = 48] = "VEC4";
+    // built-in type: vec4[]
+    TokenType[TokenType["VEC4_ARRAY"] = 49] = "VEC4_ARRAY";
+    // built-in type: bvec2
+    TokenType[TokenType["BVEC2"] = 50] = "BVEC2";
+    // built-in type: bvec2[]
+    TokenType[TokenType["BVEC2_ARRAY"] = 51] = "BVEC2_ARRAY";
+    // built-in type: bvec3
+    TokenType[TokenType["BVEC3"] = 52] = "BVEC3";
+    // built-in type: bvec3[]
+    TokenType[TokenType["BVEC3_ARRAY"] = 53] = "BVEC3_ARRAY";
+    // built-in type: bvec4
+    TokenType[TokenType["BVEC4"] = 54] = "BVEC4";
+    // built-in type: bvec4[]
+    TokenType[TokenType["BVEC4_ARRAY"] = 55] = "BVEC4_ARRAY";
+    // built-in type: ivec2
+    TokenType[TokenType["IVEC2"] = 56] = "IVEC2";
+    // built-in type: ivec2[]
+    TokenType[TokenType["IVEC2_ARRAY"] = 57] = "IVEC2_ARRAY";
+    // built-in type: ivec3
+    TokenType[TokenType["IVEC3"] = 58] = "IVEC3";
+    // built-in type: ivec3[]
+    TokenType[TokenType["IVEC3_ARRAY"] = 59] = "IVEC3_ARRAY";
+    // built-in type: ivec4
+    TokenType[TokenType["IVEC4"] = 60] = "IVEC4";
+    // built-in type: ivec4[]
+    TokenType[TokenType["IVEC4_ARRAY"] = 61] = "IVEC4_ARRAY";
+    // built-in type: uvec2
+    TokenType[TokenType["UVEC2"] = 62] = "UVEC2";
+    // built-in type: uvec2[]
+    TokenType[TokenType["UVEC2_ARRAY"] = 63] = "UVEC2_ARRAY";
+    // built-in type: uvec3
+    TokenType[TokenType["UVEC3"] = 64] = "UVEC3";
+    // built-in type: uvec3[]
+    TokenType[TokenType["UVEC3_ARRAY"] = 65] = "UVEC3_ARRAY";
+    // built-in type: uvec4
+    TokenType[TokenType["UVEC4"] = 66] = "UVEC4";
+    // built-in type: uvec4[]
+    TokenType[TokenType["UVEC4_ARRAY"] = 67] = "UVEC4_ARRAY";
+    // built-in type: mat2x2
+    TokenType[TokenType["MAT2x2"] = 68] = "MAT2x2";
+    // built-in type: mat2x2[]
+    TokenType[TokenType["MAT2x2_ARRAY"] = 69] = "MAT2x2_ARRAY";
+    // built-in type: mat2x3
+    TokenType[TokenType["MAT2x3"] = 70] = "MAT2x3";
+    // built-in type: mat2x3[]
+    TokenType[TokenType["MAT2x3_ARRAY"] = 71] = "MAT2x3_ARRAY";
+    // built-in type: mat2x4
+    TokenType[TokenType["MAT2x4"] = 72] = "MAT2x4";
+    // built-in type: mat2x4[]
+    TokenType[TokenType["MAT2x4_ARRAY"] = 73] = "MAT2x4_ARRAY";
+    // built-in type: mat3x2
+    TokenType[TokenType["MAT3x2"] = 74] = "MAT3x2";
+    // built-in type: mat3x2[]
+    TokenType[TokenType["MAT3x2_ARRAY"] = 75] = "MAT3x2_ARRAY";
+    // built-in type: mat3x3
+    TokenType[TokenType["MAT3x3"] = 76] = "MAT3x3";
+    // built-in type: mat3x3[]
+    TokenType[TokenType["MAT3x3_ARRAY"] = 77] = "MAT3x3_ARRAY";
+    // built-in type: mat3x4
+    TokenType[TokenType["MAT3x4"] = 78] = "MAT3x4";
+    // built-in type: mat3x4[]
+    TokenType[TokenType["MAT3x4_ARRAY"] = 79] = "MAT3x4_ARRAY";
+    // built-in type: mat4x2
+    TokenType[TokenType["MAT4x2"] = 80] = "MAT4x2";
+    // built-in type: mat4x2[]
+    TokenType[TokenType["MAT4x2_ARRAY"] = 81] = "MAT4x2_ARRAY";
+    // built-in type: mat4x3
+    TokenType[TokenType["MAT4x3"] = 82] = "MAT4x3";
+    // built-in type: mat4x3[]
+    TokenType[TokenType["MAT4x3_ARRAY"] = 83] = "MAT4x3_ARRAY";
+    // built-in type: mat4x4
+    TokenType[TokenType["MAT4x4"] = 84] = "MAT4x4";
+    // built-in type: mat4x4[]
+    TokenType[TokenType["MAT4x4_ARRAY"] = 85] = "MAT4x4_ARRAY";
+    // built-in type: sampler
+    TokenType[TokenType["SAMPLER"] = 86] = "SAMPLER";
+    // built-in type: sampler1D
+    TokenType[TokenType["SAMPLER_1D"] = 87] = "SAMPLER_1D";
+    // built-in type: sampler2D
+    TokenType[TokenType["SAMPLER_2D"] = 88] = "SAMPLER_2D";
+    // built-in type: sampler3D
+    TokenType[TokenType["SAMPLER_3D"] = 89] = "SAMPLER_3D";
+    // built-in type: samplerCube
+    TokenType[TokenType["SAMPLER_CUBE"] = 90] = "SAMPLER_CUBE";
+    // built-in type: samplerShadow
+    TokenType[TokenType["SAMPLER_SHADOW"] = 91] = "SAMPLER_SHADOW";
+    // built-in type: sampler1DShadow
+    TokenType[TokenType["SAMPLER_1D_SHADOW"] = 92] = "SAMPLER_1D_SHADOW";
+    // built-in type: sampler2DShadow
+    TokenType[TokenType["SAMPLER_2D_SHADOW"] = 93] = "SAMPLER_2D_SHADOW";
+    // built-in type: texture1D
+    TokenType[TokenType["TEXTURE_1D"] = 94] = "TEXTURE_1D";
+    // built-in type: texture1DArray
+    TokenType[TokenType["TEXTURE_1D_ARRAY"] = 95] = "TEXTURE_1D_ARRAY";
+    // built-in type: texture2D
+    TokenType[TokenType["TEXTURE_2D"] = 96] = "TEXTURE_2D";
+    // built-in type: texture2DArray
+    TokenType[TokenType["TEXTURE_2D_ARRAY"] = 97] = "TEXTURE_2D_ARRAY";
+    // built-in type: texture3D
+    TokenType[TokenType["TEXTURE_3D"] = 98] = "TEXTURE_3D";
+    // built-in type: textureCube
+    TokenType[TokenType["TEXTURE_CUBE"] = 99] = "TEXTURE_CUBE";
+    // built-in type: textureCubeArray
+    TokenType[TokenType["TEXTURE_CUBE_ARRAY"] = 100] = "TEXTURE_CUBE_ARRAY";
+    // built-in type end
+    TokenType[TokenType["EndBuiltinType"] = 101] = "EndBuiltinType";
+    // operator begin
+    TokenType[TokenType["BeginOperation"] = 102] = "BeginOperation";
+    // operator +
+    TokenType[TokenType["ADD"] = 103] = "ADD";
+    // operator -
+    TokenType[TokenType["SUB"] = 104] = "SUB";
+    // operator *
+    TokenType[TokenType["MUL"] = 105] = "MUL";
+    // operator /
+    TokenType[TokenType["DIV"] = 106] = "DIV";
+    // operator &&
+    TokenType[TokenType["AND"] = 107] = "AND";
+    // operator ||
+    TokenType[TokenType["OR"] = 108] = "OR";
+    // operator ^^
+    TokenType[TokenType["XOR"] = 109] = "XOR";
+    // operator !
+    TokenType[TokenType["NOT"] = 110] = "NOT";
+    // operator &
+    TokenType[TokenType["BITAND"] = 111] = "BITAND";
+    // operator |
+    TokenType[TokenType["BITOR"] = 112] = "BITOR";
+    // operator ^
+    TokenType[TokenType["BITXOR"] = 113] = "BITXOR";
+    // operator ~
+    TokenType[TokenType["BITNOT"] = 114] = "BITNOT";
+    // operator <<
+    TokenType[TokenType["BITSHIFT_L"] = 115] = "BITSHIFT_L";
+    // operator >>
+    TokenType[TokenType["BITSHIFT_R"] = 116] = "BITSHIFT_R";
+    // operator ++
+    TokenType[TokenType["INC"] = 117] = "INC";
+    // operator --
+    TokenType[TokenType["DEC"] = 118] = "DEC";
+    // operator >
+    TokenType[TokenType["GREATER"] = 119] = "GREATER";
+    // operator >=
+    TokenType[TokenType["GREATEREQUAL"] = 120] = "GREATEREQUAL";
+    // operator ==
+    TokenType[TokenType["EQUAL"] = 121] = "EQUAL";
+    // operator <
+    TokenType[TokenType["LESS"] = 122] = "LESS";
+    // operator <=
+    TokenType[TokenType["LESSEQUAL"] = 123] = "LESSEQUAL";
+    // operator !=
+    TokenType[TokenType["NOTEQUAL"] = 124] = "NOTEQUAL";
+    // operator .
+    TokenType[TokenType["DOT"] = 125] = "DOT";
+    // operator =
+    TokenType[TokenType["ASSIGN"] = 126] = "ASSIGN";
+    // operator end
+    TokenType[TokenType["EndOperation"] = 127] = "EndOperation";
+    // assigning operator begin
+    TokenType[TokenType["BeginAssignOperation"] = 128] = "BeginAssignOperation";
+    // operator +=
+    TokenType[TokenType["ADDASSIGN"] = 129] = "ADDASSIGN";
+    // operator -=
+    TokenType[TokenType["SUBASSIGN"] = 130] = "SUBASSIGN";
+    // operator *=
+    TokenType[TokenType["MULASSIGN"] = 131] = "MULASSIGN";
+    // operator /=
+    TokenType[TokenType["DIVASSIGN"] = 132] = "DIVASSIGN";
+    // assigning operator end
+    TokenType[TokenType["EndAssignOperation"] = 133] = "EndAssignOperation";
+})(TokenType || (TokenType = {}));

package/dist/src/gfx/graphics/webGpu/shader/converter/GLSLPreprocessor.d.ts

@@ -0,0 +1,10 @@
+import { Reader } from "./Reader";
+export declare class GLSLPreprocessor extends Reader {
+    private _result;
+    private _skipLine;
+    private _definitionTables;
+    constructor(source: string);
+    private parse;
+    get source(): string;
+    private parseArgs;
+}

package/dist/src/gfx/graphics/webGpu/shader/converter/GLSLPreprocessor.js

@@ -0,0 +1,198 @@
+import { Reader } from "./Reader";
+class MacroSubstitution {
+    constructor() {
+        this.name = "";
+        this.value = "";
+        this.args = [];
+    }
+}
+export class GLSLPreprocessor extends Reader {
+    constructor(source) {
+        super(source);
+        this._result = "";
+        this._skipLine = false;
+        this._definitionTables = new Map();
+        this.parse();
+    }
+    parse() {
+        this.readChar();
+        while (this._char !== "\0") {
+            this.skipWhitespace();
+            // Skip the comments
+            if (this._char === "/") {
+                // Skip single-line comments
+                if (this.peekChar() === "/") {
+                    this.skipComment();
+                    continue;
+                }
+                // Skip multi-line comments
+                if (this.peekChar() === "*") {
+                    this.skipMultilineComment();
+                    continue;
+                }
+            }
+            // Preprocessing command
+            if (this._char === "#") {
+                this.readCharAndSkipWhitespace();
+                var name = this.readIdentifier();
+                switch (name) {
+                    case "version":
+                        let version = this.readLine().trim();
+                        break;
+                    case "define":
+                        this.readCharAndSkipWhitespace();
+                        var defineName = this.readIdentifier();
+                        if (this.getChar() === "(") {
+                            let macro = new MacroSubstitution();
+                            this.readCharAndSkipWhitespace();
+                            if (this.getChar() !== ")") {
+                                do {
+                                    var argName = this.readIdentifier();
+                                    macro.args.push(argName);
+                                    this.skipWhitespace();
+                                    if (this.getChar() === ",") {
+                                        this.readCharAndSkipWhitespace();
+                                        continue;
+                                    }
+                                } while (this.getChar() !== ")");
+                            }
+                            this.readCharAndSkipWhitespace();
+                            macro.name = defineName;
+                            macro.value = this.readLine().trim();
+                            this._definitionTables.set(defineName, macro);
+                            this.readCharAndSkipWhitespace();
+                        }
+                        else {
+                            let defineValue = this.readLine().trim();
+                            if (defineValue[0] == "=") {
+                                defineValue = defineValue.substring(1);
+                            }
+                            this._definitionTables.set(defineName, defineValue);
+                        }
+                        break;
+                    case "if":
+                        let condition = this.readLine().trim();
+                        if (condition == "0" || condition == "false") {
+                            this._skipLine = true;
+                            break;
+                        }
+                        if (this._definitionTables.has(condition)) {
+                            condition = this._definitionTables.get(condition);
+                            if (condition == "0" || condition == "false") {
+                                this._skipLine = true;
+                                break;
+                            }
+                        }
+                        break;
+                    case "ifdef":
+                        this.readCharAndSkipWhitespace();
+                        var value = this.readIdentifier();
+                        this._skipLine = !this._definitionTables.has(value);
+                        break;
+                    case "else":
+                        this._skipLine = !this._skipLine;
+                        break;
+                    case "endif":
+                        this._skipLine = false;
+                        break;
+                    default:
+                        throw "Unknown preprocessing command:" + name;
+                }
+            }
+            else {
+                var line = this.readLine();
+                if (!this._skipLine) {
+                    for (let key of this._definitionTables.keys()) {
+                        let index = line.indexOf(key);
+                        if (index != -1) {
+                            let value = this._definitionTables.get(key);
+                            if (typeof value === "string") {
+                                line = line.replace(key, value);
+                            }
+                            else {
+                                let macro = value;
+                                let reader = new Reader(line.substring(index + key.length));
+                                reader.readCharAndSkipWhitespace();
+                                if (reader.getChar() === "(") {
+                                    reader.readCharAndSkipWhitespace();
+                                    for (let count = 1; reader.getChar() !== "\0" && count > 0;) {
+                                        switch (reader.getChar()) {
+                                            case "(":
+                                                count++;
+                                                break;
+                                            case ")":
+                                                count--;
+                                                break;
+                                        }
+                                        reader.readCharAndSkipWhitespace();
+                                    }
+                                }
+                                let nBeginPos = index;
+                                let nEndPos = nBeginPos + key.length + reader.currPosition;
+                                let expr = line.substring(nBeginPos, nEndPos).trim();
+                                if (macro.args.length > 0) {
+                                    let args = [];
+                                    let argsStr = expr
+                                        .substring(expr.indexOf("(") + 1, expr.lastIndexOf(")"))
+                                        .trim();
+                                    if (argsStr.length > 0) {
+                                        args = this.parseArgs(argsStr);
+                                    }
+                                    let macroValue = macro.value.substring(macro.value.indexOf("("));
+                                    for (let i = 0; i < macro.args.length; i++) {
+                                        macroValue = macroValue.replace(macro.args[i], args[i]);
+                                    }
+                                    macroValue =
+                                        macro.value.substring(0, macro.value.indexOf("(")) +
+                                            macroValue;
+                                    line = line.replace(expr, macroValue);
+                                }
+                                else {
+                                    line = line.replace(expr, macro.value);
+                                }
+                            }
+                        }
+                    }
+                    this._result += line;
+                }
+                this.readChar();
+            }
+        }
+    }
+    get source() {
+        return this._result;
+    }
+    parseArgs(str) {
+        let result = [];
+        let count = 0;
+        let reader = new Reader(str);
+        let position = reader.currPosition;
+        reader.readCharAndSkipWhitespace();
+        if (reader.getChar() !== "\0") {
+            reader.readCharAndSkipWhitespace();
+            for (; reader.getChar() !== "\0";) {
+                switch (reader.getChar()) {
+                    case "(":
+                        count++;
+                        break;
+                    case ")":
+                        count--;
+                        break;
+                    case ",":
+                        if (count == 0) {
+                            let arg = str.substring(position, reader.currPosition);
+                            result.push(arg);
+                            position = reader.currPosition + 1;
+                        }
+                        break;
+                }
+                reader.readCharAndSkipWhitespace();
+            }
+        }
+        if (position < reader.currPosition) {
+            let arg = str.substring(position, reader.currPosition);
+            result.push(arg);
+        }
+        return result;
+    }
+}

package/dist/src/gfx/graphics/webGpu/shader/converter/GLSLSyntax.d.ts

@@ -0,0 +1,14 @@
+import { GLSLLexer } from "./GLSLLexer";
+import { StatementNode } from "./StatementNode";
+export declare class GLSLSyntax {
+    private _lexer;
+    private _rootNode;
+    constructor(input: GLSLLexer);
+    get lexer(): GLSLLexer;
+    private parse;
+    private parseStatement;
+    private skipToken;
+    private peekToken;
+    private getNextToken;
+    get ASTRoot(): StatementNode;
+}