@rings-webgpu/core 1.0.0 → 1.0.2

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

@@ -0,0 +1,422 @@
+import { GLSLLexerToken, TokenType } from "./GLSLLexerToken";
+import { Reader } from "./Reader";
+export class GLSLLexer extends Reader {
+    constructor(input) {
+        super(input.source);
+        this._tokenPosition = 0;
+        this._tokens = [];
+        this.parse();
+    }
+    skipToken(offset) {
+        this._tokenPosition += offset;
+    }
+    peekToken(offset) {
+        if (this._tokenPosition + offset >= this._tokens.length) {
+            return new GLSLLexerToken(TokenType.EOF, "\0");
+        }
+        return this._tokens[this._tokenPosition + offset];
+    }
+    GetNextToken() {
+        if (this._tokenPosition >= this._tokens.length) {
+            return new GLSLLexerToken(TokenType.EOF, "\0");
+        }
+        let result = this._tokens[this._tokenPosition];
+        this._tokenPosition++;
+        return result;
+    }
+    get currTokenPosition() {
+        return this._tokenPosition;
+    }
+    // start to parse
+    parse() {
+        this.readChar();
+        this._tokens = new Array();
+        var token;
+        do {
+            token = this.nextToken();
+            this._tokens.push(token);
+        } while (token.Type != TokenType.EOF);
+    }
+    // get next token
+    nextToken() {
+        this.skipWhitespace();
+        // ignore code annotation
+        if (this._char === "/") {
+            // code annotation for single line
+            if (this.peekChar() === "/") {
+                this.skipComment();
+                return this.nextToken();
+            }
+            // code annotation of multiple line
+            if (this.peekChar() === "*") {
+                this.skipMultilineComment();
+                return this.nextToken();
+            }
+        }
+        var token = new GLSLLexerToken();
+        token.Line = this._line;
+        token.Colume = this._column;
+        switch (this._char) {
+            case "\0":
+                token.Type = TokenType.EOF;
+                token.Literal = "EOF";
+                break;
+            case ".":
+                token.Type = TokenType.DOT;
+                token.Literal = ".";
+                break;
+            case ",":
+                token.Type = TokenType.COMMA;
+                token.Literal = ",";
+                break;
+            case ":":
+                token.Type = TokenType.COLON;
+                token.Literal = ":";
+                break;
+            case "?":
+                token.Type = TokenType.QUEMARK;
+                token.Literal = "?";
+                break;
+            case ";":
+                token.Type = TokenType.SEMICOLON;
+                token.Literal = ";";
+                break;
+            case "(":
+                token.Type = TokenType.LEFTSAMLL;
+                token.Literal = "(";
+                break;
+            case ")":
+                token.Type = TokenType.RIGHTSAMLL;
+                token.Literal = ")";
+                break;
+            case "[":
+                token.Type = TokenType.LEFTMEDI;
+                token.Literal = "[";
+                break;
+            case "]":
+                token.Type = TokenType.RIGHTMEDI;
+                token.Literal = "]";
+                break;
+            case "{":
+                token.Type = TokenType.LEFTBIG;
+                token.Literal = "{";
+                break;
+            case "}":
+                token.Type = TokenType.RIGHTBIG;
+                token.Literal = "}";
+                break;
+            case "+":
+                if (this.peekChar() === "+") {
+                    this.readChar();
+                    token.Type = TokenType.INC;
+                    token.Literal = "++";
+                    break;
+                }
+                else if (this.peekChar() === "=") {
+                    this.readChar();
+                    token.Type = TokenType.ADDASSIGN;
+                    token.Literal = "+=";
+                    break;
+                }
+                token.Type = TokenType.ADD;
+                token.Literal = "+";
+                break;
+            case "-":
+                if (this.peekChar() === "-") {
+                    this.readChar();
+                    token.Type = TokenType.DEC;
+                    token.Literal = "--";
+                    break;
+                }
+                else if (this.peekChar() === "=") {
+                    this.readChar();
+                    token.Type = TokenType.SUBASSIGN;
+                    token.Literal = "-=";
+                    break;
+                }
+                token.Type = TokenType.SUB;
+                token.Literal = "-";
+                break;
+            case "*":
+                if (this.peekChar() === "=") {
+                    this.readChar();
+                    token.Type = TokenType.MULASSIGN;
+                    token.Literal = "*=";
+                    break;
+                }
+                token.Type = TokenType.MUL;
+                token.Literal = "*";
+                break;
+            case "/":
+                if (this.peekChar() === "=") {
+                    this.readChar();
+                    token.Type = TokenType.DIVASSIGN;
+                    token.Literal = "/=";
+                    break;
+                }
+                token.Type = TokenType.DIV;
+                token.Literal = "/";
+                break;
+            case "&":
+                if (this.peekChar() === "&") {
+                    this.readChar();
+                    token.Type = TokenType.AND;
+                    token.Literal = "&&";
+                    break;
+                }
+                token.Type = TokenType.BITAND;
+                token.Literal = "&";
+                break;
+            case "|":
+                if (this.peekChar() === "|") {
+                    this.readChar();
+                    token.Type = TokenType.OR;
+                    token.Literal = "||";
+                    break;
+                }
+                token.Type = TokenType.BITOR;
+                token.Literal = "&";
+                break;
+            case "^":
+                token.Type = TokenType.BITXOR;
+                token.Literal = "^";
+                break;
+            case "!":
+                if (this.peekChar() === "=") {
+                    this.readChar();
+                    token.Type = TokenType.NOTEQUAL;
+                    token.Literal = "!=";
+                    break;
+                }
+                token.Type = TokenType.NOT;
+                token.Literal = "!";
+                break;
+            case ">":
+                if (this.peekChar() === "=") {
+                    this.readChar();
+                    token.Type = TokenType.GREATEREQUAL;
+                    token.Literal = ">=";
+                    break;
+                }
+                else if (this.peekChar() === ">") {
+                    this.readChar();
+                    token.Type = TokenType.BITSHIFT_R;
+                    token.Literal = ">>";
+                    break;
+                }
+                token.Type = TokenType.GREATER;
+                token.Literal = ">";
+                break;
+            case "=":
+                if (this.peekChar() === "=") {
+                    this.readChar();
+                    token.Type = TokenType.EQUAL;
+                    token.Literal = "==";
+                    break;
+                }
+                token.Type = TokenType.ASSIGN;
+                token.Literal = "=";
+                break;
+            case "<":
+                if (this.peekChar() === "=") {
+                    this.readChar();
+                    token.Type = TokenType.LESSEQUAL;
+                    token.Literal = "<=";
+                    break;
+                }
+                else if (this.peekChar() === "<") {
+                    this.readChar();
+                    token.Type = TokenType.BITSHIFT_L;
+                    token.Literal = "<<";
+                    break;
+                }
+                token.Type = TokenType.LESS;
+                token.Literal = "<";
+                break;
+            default:
+                if (this.isDigit(this._char)) {
+                    return this.readDecimal();
+                }
+                token.Literal = this.readIdentifier();
+                token.Type = this.lookupIdentifier(token.Literal);
+                if (this.getChar() == "[" &&
+                    this.peekChar() == "]" &&
+                    token.isBuiltinType()) {
+                    token.Type++;
+                    token.Literal += "[]";
+                    this.readChar();
+                    this.readChar();
+                }
+                return token;
+        }
+        this.readChar();
+        return token;
+    }
+    // read dicimal
+    readDecimal() {
+        var token = new GLSLLexerToken();
+        token.Line = this._line;
+        token.Colume = this._column;
+        token.Type = TokenType.LITERAL;
+        var integer = this.readNumber();
+        if (this._char === "e") {
+            token.Literal = integer + this._char;
+            this.readChar();
+            token.Literal += this._char;
+            this.readChar();
+            token.Literal += this.readNumber();
+            token.Type = TokenType.LITERAL; // TokenType.FLOAT;
+            return token;
+        }
+        if (this._char === "u") {
+            this.readChar();
+            token.Type = TokenType.LITERAL; // TokenType.UINT;
+            token.Literal = integer + "u";
+            return token;
+        }
+        if (this._char === "f") {
+            this.readChar();
+            token.Type = TokenType.LITERAL; // TokenType.FLOAT;
+            token.Literal = integer + "f";
+            return token;
+        }
+        token.Type = TokenType.LITERAL; // TokenType.INT;
+        token.Literal = integer;
+        return token;
+    }
+    lookupIdentifier(literal) {
+        switch (literal) {
+            case "void":
+                return TokenType.VOID;
+            case "int":
+                return TokenType.INT;
+            case "uint":
+                return TokenType.UINT;
+            case "bool":
+                return TokenType.BOOL;
+            case "true":
+                return TokenType.BOOL;
+            case "false":
+                return TokenType.BOOL;
+            case "float":
+                return TokenType.FLOAT;
+            case "vec2":
+                return TokenType.VEC2;
+            case "vec3":
+                return TokenType.VEC3;
+            case "vec4":
+                return TokenType.VEC4;
+            case "bvec2":
+                return TokenType.BVEC2;
+            case "bvec3":
+                return TokenType.BVEC3;
+            case "bvec4":
+                return TokenType.BVEC4;
+            case "ivec2":
+                return TokenType.IVEC2;
+            case "ivec3":
+                return TokenType.IVEC3;
+            case "ivec4":
+                return TokenType.IVEC4;
+            case "uvec2":
+                return TokenType.UVEC2;
+            case "uvec3":
+                return TokenType.UVEC3;
+            case "uvec4":
+                return TokenType.UVEC4;
+            case "mat2":
+                return TokenType.MAT2x2;
+            case "mat2x2":
+                return TokenType.MAT2x2;
+            case "mat2x3":
+                return TokenType.MAT2x3;
+            case "mat2x4":
+                return TokenType.MAT2x4;
+            case "mat3":
+                return TokenType.MAT3x3;
+            case "mat3x2":
+                return TokenType.MAT3x2;
+            case "mat3x3":
+                return TokenType.MAT3x3;
+            case "mat3x4":
+                return TokenType.MAT3x4;
+            case "mat4":
+                return TokenType.MAT4x4;
+            case "mat4x2":
+                return TokenType.MAT4x2;
+            case "mat4x3":
+                return TokenType.MAT4x3;
+            case "mat4x4":
+                return TokenType.MAT4x4;
+            case "sampler":
+                return TokenType.SAMPLER;
+            case "sampler1D":
+                return TokenType.SAMPLER_1D;
+            case "sampler2D":
+                return TokenType.SAMPLER_2D;
+            case "sampler3D":
+                return TokenType.SAMPLER_3D;
+            case "samplerCube":
+                return TokenType.SAMPLER_CUBE;
+            case "samplerShadow":
+                return TokenType.SAMPLER_SHADOW;
+            case "sampler1DShadow":
+                return TokenType.SAMPLER_1D_SHADOW;
+            case "sampler2DShadow":
+                return TokenType.SAMPLER_2D_SHADOW;
+            case "texture1D":
+                return TokenType.TEXTURE_1D;
+            case "texture2D":
+                return TokenType.TEXTURE_2D;
+            case "texture3D":
+                return TokenType.TEXTURE_3D;
+            case "textureCube":
+                return TokenType.TEXTURE_CUBE;
+            case "texture1DArray":
+                return TokenType.TEXTURE_1D_ARRAY;
+            case "texture2DArray":
+                return TokenType.TEXTURE_2D_ARRAY;
+            case "textureCubeArray":
+                return TokenType.TEXTURE_CUBE_ARRAY;
+            case "const":
+                return TokenType.CONST;
+            case "layout":
+                return TokenType.LAYOUT;
+            case "precision":
+                return TokenType.PRECISION;
+            case "attribute":
+                return TokenType.ATTRIBUTE;
+            case "uniform":
+                return TokenType.UNIFORM;
+            case "varying":
+                return TokenType.VARYING;
+            case "invariant":
+                return TokenType.INVARIANT;
+            case "in":
+                return TokenType.IN;
+            case "out":
+                return TokenType.OUT;
+            case "inout":
+                return TokenType.INOUT;
+            case "if":
+                return TokenType.IF;
+            case "else":
+                return TokenType.ELSE;
+            case "for":
+                return TokenType.FOR;
+            case "while":
+                return TokenType.WHILE;
+            case "do":
+                return TokenType.DO;
+            case "break":
+                return TokenType.BREAK;
+            case "return":
+                return TokenType.RETURN;
+            case "continue":
+                return TokenType.CONTINUE;
+            case "struct":
+                return TokenType.STRUCT;
+        }
+        return TokenType.IDENT;
+    }
+}

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

@@ -0,0 +1,174 @@
+export declare class GLSLLexerToken {
+    Type: TokenType;
+    Line: number;
+    Colume: number;
+    Literal: string;
+    constructor(type?: TokenType, literal?: string);
+    /**
+     * @returns determin the type is same to token
+     */
+    isTypeEqual(type: TokenType): boolean;
+    /**
+     * @returns determin the value is same
+     */
+    isLiteralEqual(literal: string): boolean;
+    /**
+     * @returns determin it's builtin type
+     */
+    isBuiltinType(): boolean;
+    /**
+     * @returns determin it's a data type
+     */
+    isDataType(): boolean;
+    /**
+     * @returns determin it's a operation
+     */
+    isOperation(): boolean;
+    /**
+     * @returns determin it's a assign operation
+     */
+    isAssignOperation(): boolean;
+    /**
+     * The priority of the current operator
+     */
+    get nOperationPriorityLevel(): number;
+}
+/**
+ * @internal
+ */
+export declare enum TokenType {
+    EOF = 0,
+    IDENT = 1,
+    VOID = 2,
+    CONST = 3,
+    LAYOUT = 4,
+    PRECISION = 5,
+    ATTRIBUTE = 6,
+    UNIFORM = 7,
+    VARYING = 8,
+    INVARIANT = 9,
+    IN = 10,
+    OUT = 11,
+    INOUT = 12,
+    IF = 13,
+    ELSE = 14,
+    FOR = 15,
+    WHILE = 16,
+    DO = 17,
+    BREAK = 18,
+    RETURN = 19,
+    CONTINUE = 20,
+    STRUCT = 21,
+    COMMA = 22,
+    COLON = 23,
+    QUEMARK = 24,
+    SEMICOLON = 25,
+    LEFTSAMLL = 26,
+    RIGHTSAMLL = 27,
+    LEFTMEDI = 28,
+    RIGHTMEDI = 29,
+    LEFTBIG = 30,
+    RIGHTBIG = 31,
+    LITERAL = 32,
+    BeginBuiltinType = 33,
+    INT = 34,
+    INT_ARRAY = 35,
+    UINT = 36,
+    UINT_ARRAY = 37,
+    BOOL = 38,
+    BOOL_ARRAY = 39,
+    FLOAT = 40,
+    FLOAT_ARRAY = 41,
+    DOUBLE = 42,
+    DOUBLE_ARRAY = 43,
+    VEC2 = 44,
+    VEC2_ARRAY = 45,
+    VEC3 = 46,
+    VEC3_ARRAY = 47,
+    VEC4 = 48,
+    VEC4_ARRAY = 49,
+    BVEC2 = 50,
+    BVEC2_ARRAY = 51,
+    BVEC3 = 52,
+    BVEC3_ARRAY = 53,
+    BVEC4 = 54,
+    BVEC4_ARRAY = 55,
+    IVEC2 = 56,
+    IVEC2_ARRAY = 57,
+    IVEC3 = 58,
+    IVEC3_ARRAY = 59,
+    IVEC4 = 60,
+    IVEC4_ARRAY = 61,
+    UVEC2 = 62,
+    UVEC2_ARRAY = 63,
+    UVEC3 = 64,
+    UVEC3_ARRAY = 65,
+    UVEC4 = 66,
+    UVEC4_ARRAY = 67,
+    MAT2x2 = 68,
+    MAT2x2_ARRAY = 69,
+    MAT2x3 = 70,
+    MAT2x3_ARRAY = 71,
+    MAT2x4 = 72,
+    MAT2x4_ARRAY = 73,
+    MAT3x2 = 74,
+    MAT3x2_ARRAY = 75,
+    MAT3x3 = 76,
+    MAT3x3_ARRAY = 77,
+    MAT3x4 = 78,
+    MAT3x4_ARRAY = 79,
+    MAT4x2 = 80,
+    MAT4x2_ARRAY = 81,
+    MAT4x3 = 82,
+    MAT4x3_ARRAY = 83,
+    MAT4x4 = 84,
+    MAT4x4_ARRAY = 85,
+    SAMPLER = 86,
+    SAMPLER_1D = 87,
+    SAMPLER_2D = 88,
+    SAMPLER_3D = 89,
+    SAMPLER_CUBE = 90,
+    SAMPLER_SHADOW = 91,
+    SAMPLER_1D_SHADOW = 92,
+    SAMPLER_2D_SHADOW = 93,
+    TEXTURE_1D = 94,
+    TEXTURE_1D_ARRAY = 95,
+    TEXTURE_2D = 96,
+    TEXTURE_2D_ARRAY = 97,
+    TEXTURE_3D = 98,
+    TEXTURE_CUBE = 99,
+    TEXTURE_CUBE_ARRAY = 100,
+    EndBuiltinType = 101,
+    BeginOperation = 102,
+    ADD = 103,
+    SUB = 104,
+    MUL = 105,
+    DIV = 106,
+    AND = 107,
+    OR = 108,
+    XOR = 109,
+    NOT = 110,
+    BITAND = 111,
+    BITOR = 112,
+    BITXOR = 113,
+    BITNOT = 114,
+    BITSHIFT_L = 115,
+    BITSHIFT_R = 116,
+    INC = 117,
+    DEC = 118,
+    GREATER = 119,
+    GREATEREQUAL = 120,
+    EQUAL = 121,
+    LESS = 122,
+    LESSEQUAL = 123,
+    NOTEQUAL = 124,
+    DOT = 125,
+    ASSIGN = 126,
+    EndOperation = 127,
+    BeginAssignOperation = 128,
+    ADDASSIGN = 129,
+    SUBASSIGN = 130,
+    MULASSIGN = 131,
+    DIVASSIGN = 132,
+    EndAssignOperation = 133
+}