@rings-webgpu/core 1.0.2 → 1.0.3

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

@@ -1,1804 +0,0 @@
-import { TokenType } from "./GLSLLexerToken";
-import { TranslatorContext } from "./WGSLTranslator";
-/**
- * @internal
- * Statement node
- * @group GFX
- */
-export class StatementNode {
-    constructor() {
-        this.nodes = [];
-    }
-    addNode(node) {
-        this.nodes.push(node);
-    }
-    formatToWGSL(context, depth) {
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        return "";
-    }
-}
-/**
- * @internal
- * Statement node: struct
- * @group GFX
- */
-export class SN_Struct extends StatementNode {
-    constructor(name) {
-        super();
-        this.name = "";
-        this.fields = [];
-        this.name = name;
-    }
-    static parse(r) {
-        if (r.peekToken(0).Type == TokenType.IDENT &&
-            r.peekToken(1).Type == TokenType.LEFTBIG) {
-            let result = new SN_Struct(r.peekToken(0).Literal);
-            r.skipToken(2);
-            while (r.peekToken(0).Type != TokenType.RIGHTBIG) {
-                let field = SN_Declaration.parse(r);
-                result.fields.push(field);
-            }
-            if (r.peekToken(0).Type == TokenType.RIGHTBIG) {
-                r.skipToken(1);
-            }
-            if (r.peekToken(0).Type == TokenType.SEMICOLON) {
-                r.skipToken(1);
-            }
-            return result;
-        }
-        throw "Error parsing structure: Unexpected character";
-    }
-    formatToWGSL(context, depth) {
-        let result = "";
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        result += prefix + "struct " + this.name + " {\r\n";
-        for (let field of this.fields) {
-            if (field.arraySize.nodes.length <= 0) {
-                result +=
-                    prefix + "  " + field.name + ": " + toWGSLType(field.type) + ",\r\n";
-            }
-            else {
-                if (field.arraySize.nodes[0] instanceof SN_Constant) {
-                    result +=
-                        prefix +
-                            "  " +
-                            field.name +
-                            ": array<" +
-                            toWGSLType(field.type) +
-                            ", " +
-                            field.arraySize.nodes[0].value +
-                            ">" +
-                            ",\r\n";
-                }
-                else {
-                    result +=
-                        prefix +
-                            "  " +
-                            field.name +
-                            ": array<" +
-                            toWGSLType(field.type) +
-                            ", " +
-                            field.arraySize.nodes[0].formatToWGSL(context, 0) +
-                            ">" +
-                            ",\r\n";
-                }
-            }
-        }
-        result += prefix + "};\r\n";
-        return result;
-    }
-}
-/**
- * @internal
- * Statement node: function
- * @group GFX
- */
-export class SN_Function extends StatementNode {
-    constructor(name, args, body, returnType) {
-        super();
-        this.name = name;
-        this.args = args;
-        this.body = body;
-        this.returnType = returnType;
-    }
-    static parse(r) {
-        if ((r.peekToken(0).isBuiltinType() ||
-            r.peekToken(0).Type == TokenType.VOID) &&
-            r.peekToken(1).Type == TokenType.IDENT &&
-            r.peekToken(2).Type == TokenType.LEFTSAMLL) {
-            // Parsing return types
-            let returnType = r.peekToken(0).Literal;
-            // Parse function name
-            let name = r.peekToken(1).Literal;
-            r.skipToken(2);
-            // Parse the parameter list
-            let args = new Array();
-            if (r.peekToken(0).Type != TokenType.LEFTSAMLL) {
-                throw "Error parsing function parameter list: Unexpected character";
-            }
-            else {
-                r.skipToken(1);
-                while (r.peekToken(0).Type != TokenType.EOF) {
-                    if (r.peekToken(0).Type == TokenType.RIGHTSAMLL) {
-                        r.skipToken(1);
-                        break;
-                    }
-                    if (r.peekToken(0).Type == TokenType.INOUT) {
-                        r.skipToken(1);
-                    }
-                    else if (r.peekToken(0).Type == TokenType.IN) {
-                        r.skipToken(1);
-                    }
-                    else if (r.peekToken(0).Type == TokenType.OUT) {
-                        r.skipToken(1);
-                    }
-                    let arg = SN_Declaration.parse(r);
-                    args.push(arg);
-                    if (r.peekToken(0).Type == TokenType.COMMA) {
-                        r.skipToken(1);
-                    }
-                }
-            }
-            // Parse function body
-            let body = SN_CodeBlock.parse(r);
-            return new SN_Function(name, args, body, returnType);
-        }
-        throw "Error parsing function: Unexpected character";
-    }
-    formatToWGSL(context, depth) {
-        let result = "";
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        let outStructName;
-        let hasOutStruct = context.layoutsOut.length > 0 || context.builtinOut.length > 0;
-        switch (context.stage) {
-            case "compute":
-                outStructName = "ComputeOutput";
-                break;
-            case "vertex":
-                outStructName = "VertexOutput";
-                break;
-            case "fragment":
-                outStructName = "FragmentOutput";
-                break;
-            default:
-                outStructName = "StructOutput";
-                break;
-        }
-        // Processing the output structure
-        if (this.name == "main" && hasOutStruct) {
-            result += "struct " + outStructName + " {\r\n";
-            for (let item of context.layoutsOut) {
-                if (item.nodes[0] instanceof SN_Declaration) {
-                    let arg = item.nodes[0];
-                    if (item.qualifier.size == 1 && item.qualifier.has("location")) {
-                        result += "  @location(" + item.qualifier.get("location") + ") ";
-                    }
-                    result += arg.name + ": " + toWGSLType(arg.type) + ",\r\n";
-                    context.addIdentifier(arg.name, "stout." + arg.name);
-                }
-            }
-            let builtinOut = context.builtinOut;
-            for (let item of builtinOut) {
-                result += "  " + item + ",\r\n";
-            }
-            result += "};\r\n\r\n";
-        }
-        // Generate function header
-        let header = "";
-        if (this.name == "main") {
-            if (context.workGroupSize != undefined) {
-                header +=
-                    "@" +
-                        context.stage +
-                        " " +
-                        context.workGroupSize.formatToWGSL(context, 0) +
-                        " \r\n";
-            }
-            else {
-                header += "@" + context.stage + "\r\n";
-            }
-        }
-        context = new TranslatorContext(context);
-        header += prefix + "fn " + this.name + "(";
-        if (this.name != "main") {
-            for (let i = 0; i < this.args.length; i++) {
-                let arg = this.args[i];
-                if (i > 0) {
-                    header += ", ";
-                }
-                header += arg.name + ": " + toWGSLType(arg.type);
-                context.addIdentifier(arg.name, arg.name);
-            }
-            header += ") -> " + toWGSLType(this.returnType);
-        }
-        else {
-            let layoutsIn = context.layoutsIn;
-            for (let i = 0; i < layoutsIn.length; i++) {
-                let item = layoutsIn[i];
-                if (i > 0) {
-                    header += ",\r\n    ";
-                }
-                else {
-                    header += "\r\n    ";
-                }
-                if (item.nodes[0] instanceof SN_Declaration) {
-                    let arg = item.nodes[0];
-                    if (item.qualifier.size == 1 && item.qualifier.has("location")) {
-                        header += "@location(" + item.qualifier.get("location") + ") ";
-                    }
-                    header += arg.name + ": " + toWGSLType(arg.type);
-                    context.addIdentifier(arg.name, arg.name);
-                }
-            }
-            if (layoutsIn.length > 0) {
-                header += ",\r\n    ";
-            }
-            let builtinIn = context.builtinIn;
-            for (let item of builtinIn) {
-                header += item + ",\r\n    ";
-            }
-            if (hasOutStruct) {
-                header += ") -> " + outStructName;
-            }
-            else {
-                header += ") ";
-            }
-        }
-        // Generating function body
-        let bodyResult = "";
-        if (this.name == "main" && hasOutStruct) {
-            bodyResult += "    var stout: " + outStructName + " ;\r\n";
-        }
-        for (let statement of this.body.nodes) {
-            bodyResult += statement.formatToWGSL(context, depth + 1);
-            if (!(statement instanceof SN_IFBranch) &&
-                !(statement instanceof SN_WhileLoop) &&
-                !(statement instanceof SN_ForLoop)) {
-                bodyResult += ";\r\n";
-            }
-        }
-        if (this.name == "main" && hasOutStruct) {
-            bodyResult += "    return stout;\r\n";
-        }
-        // Result of assembly
-        result += header + " {\r\n";
-        result += bodyResult;
-        result += prefix + "}\r\n";
-        result += "\r\n";
-        return result;
-    }
-}
-/**
- * @internal
- * Statement node: functionArg
- * @group GFX
- */
-export class SN_FunctionArgs extends StatementNode {
-    constructor() {
-        super();
-        this.args = [];
-    }
-    static parse(r) {
-        if (r.peekToken(0).Type == TokenType.LEFTSAMLL) {
-            r.skipToken(1);
-            let result = new SN_FunctionArgs();
-            while (r.peekToken(0).Type != TokenType.EOF) {
-                if (r.peekToken(0).Type == TokenType.RIGHTSAMLL) {
-                    r.skipToken(1);
-                    break;
-                }
-                let arg = SN_Expression.parse(r);
-                result.args.push(arg);
-                if (r.peekToken(0).Type == TokenType.COMMA) {
-                    r.skipToken(1);
-                }
-            }
-            return result;
-        }
-        throw "Error parsing function argument table: Unexpected character";
-    }
-}
-/**
- * @internal
- * Statement node: functionCall
- * @group GFX
- */
-export class SN_FunctionCall extends StatementNode {
-    constructor(name, args) {
-        super();
-        this.name = name;
-        this.args = args;
-    }
-    static parse(r) {
-        // a(...)
-        if (r.peekToken(0).isDataType() &&
-            r.peekToken(1).Type == TokenType.LEFTSAMLL) {
-            // Parse function name
-            let name = r.peekToken(0).Literal;
-            r.skipToken(1);
-            // Parse the argument table
-            let args = SN_FunctionArgs.parse(r);
-            return new SN_FunctionCall(name, args);
-        }
-        throw "Error parsing function argument table: Unexpected character";
-    }
-    formatToWGSL(context, depth) {
-        let result = "";
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        if (this.name == "texture" &&
-            this.args.args[0].nodes[0] instanceof SN_FunctionCall) {
-            let callNode = this.args.args[0].nodes[0];
-            if (callNode.name == "sampler2D") {
-                result += prefix + "textureSample(";
-                for (let i = 0; i < callNode.args.args.length; i++) {
-                    let arg = callNode.args.args[i];
-                    if (i > 0) {
-                        result += ", ";
-                    }
-                    result += arg.formatToWGSL(context, 0);
-                }
-                for (let i = 1; i < this.args.args.length; i++) {
-                    let arg = this.args.args[i];
-                    if (i > 0) {
-                        result += ", ";
-                    }
-                    result += arg.formatToWGSL(context, 0);
-                }
-                result += ")";
-                return result;
-            }
-        }
-        result += prefix + toWGSLType(this.name) + "(";
-        for (let i = 0; i < this.args.args.length; i++) {
-            let arg = this.args.args[i];
-            if (i > 0) {
-                result += ", ";
-            }
-            result += arg.formatToWGSL(context, 0);
-        }
-        result += ")";
-        return result;
-    }
-}
-/**
- * @internal
- * Statement node: declaration
- * @group GFX
- */
-export class SN_Declaration extends StatementNode {
-    constructor(type, name, arraySize = new SN_Expression()) {
-        super();
-        this.type = type;
-        this.name = name;
-        this.hasIn = false;
-        this.hasOut = false;
-        this.hasConst = false;
-        this.arraySize = arraySize;
-    }
-    static parse(r) {
-        let result = new SN_Declaration("", "");
-        let first = r.peekToken(0);
-        // const
-        if (first.Type == TokenType.CONST) {
-            r.skipToken(1);
-            result.hasConst = true;
-        }
-        // in
-        else if (first.Type == TokenType.IN) {
-            r.skipToken(1);
-            result.hasIn = true;
-        }
-        // out
-        else if (first.Type == TokenType.OUT) {
-            r.skipToken(1);
-            result.hasOut = true;
-        }
-        // inout
-        else if (first.Type == TokenType.INOUT) {
-            r.skipToken(1);
-            result.hasIn = true;
-            result.hasOut = true;
-        }
-        else if (!first.isDataType()) {
-            throw ("Error parsing declaration expression: Unexpected character(" +
-                first.Literal +
-                ")");
-        }
-        first = r.peekToken(0);
-        // float[xxx] a
-        if (first.isDataType() && r.peekToken(1).Type == TokenType.LEFTMEDI) {
-            result.type = first.Literal;
-            r.skipToken(2);
-            result.arraySize = SN_Expression.parse(r);
-            if (r.peekToken(0).Type == TokenType.RIGHTMEDI) {
-                r.skipToken(1);
-            }
-            if (r.peekToken(0).Type != TokenType.IDENT) {
-                throw "Unexpected";
-            }
-            result.name = r.peekToken(0).Literal;
-            r.skipToken(1);
-        }
-        // float a[xxx]
-        else if (first.isDataType() &&
-            r.peekToken(1).Type == TokenType.IDENT &&
-            r.peekToken(2).Type == TokenType.LEFTMEDI) {
-            result.type = r.peekToken(0).Literal;
-            result.name = r.peekToken(1).Literal;
-            r.skipToken(3);
-            if (r.peekToken(0).Type == TokenType.RIGHTMEDI) {
-                r.skipToken(1);
-            }
-            else {
-                result.arraySize = SN_Expression.parse(r);
-                if (r.peekToken(0).Type == TokenType.RIGHTMEDI) {
-                    r.skipToken(1);
-                }
-            }
-        }
-        // float a
-        else if (first.isDataType() && r.peekToken(1).Type == TokenType.IDENT) {
-            result.type = r.peekToken(0).Literal;
-            result.name = r.peekToken(1).Literal;
-            r.skipToken(2);
-        }
-        else
-            throw ("Error parsing declaration expression: Unexpected character(" +
-                first.Literal +
-                ")");
-        first = r.peekToken(0);
-        if (first.Type == TokenType.SEMICOLON) {
-            r.skipToken(1);
-            return result;
-        }
-        else if (first.Type == TokenType.RIGHTSAMLL) {
-            return result;
-        }
-        else if (first.Type == TokenType.ASSIGN) {
-            let op = r.peekToken(0);
-            r.skipToken(1);
-            let lValue = new SN_Identifier(result.name);
-            let rValue = SN_Expression.parse(r);
-            if (r.peekToken(0).Type == TokenType.SEMICOLON) {
-                r.skipToken(1);
-            }
-            result.addNode(new SN_BinaryOperation(op, lValue, rValue));
-            return result;
-        }
-        else if (first.Type == TokenType.COMMA) {
-            // float a, b = 0, c = 1 + 2
-            while (r.peekToken(0).Type == TokenType.COMMA &&
-                r.peekToken(1).Type == TokenType.IDENT) {
-                let declaration = new SN_Declaration(result.type, r.peekToken(1).Literal);
-                result.addNode(declaration);
-                r.skipToken(2);
-                if (r.peekToken(0).Type == TokenType.ASSIGN) {
-                    r.skipToken(-1);
-                    declaration.addNode(SN_Expression.parse(r));
-                }
-            }
-            return result;
-        }
-        throw ("Error parsing declaration expression: Unexpected character(" +
-            r.peekToken(0).Literal +
-            ")");
-    }
-    formatToWGSL(context, depth) {
-        let result = "";
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        if (this.hasConst) {
-            result += prefix + "let ";
-        }
-        else {
-            result += prefix + "var ";
-        }
-        context.addIdentifier(this.name, this.name);
-        if (this.arraySize.nodes.length <= 0) {
-            result += this.name + ": " + toWGSLType(this.type);
-        }
-        else {
-            if (this.arraySize.nodes[0] instanceof SN_Constant) {
-                result +=
-                    this.name +
-                        ": array<" +
-                        toWGSLType(this.type) +
-                        ", " +
-                        this.arraySize.nodes[0].value +
-                        ">";
-            }
-            else {
-                result +=
-                    this.name +
-                        ": array<" +
-                        toWGSLType(this.type) +
-                        ", " +
-                        this.arraySize.nodes[0].formatToWGSL(context, 0) +
-                        ">";
-            }
-        }
-        if (this.nodes.length > 0 && this.nodes[0] instanceof SN_BinaryOperation) {
-            result += " = " + this.nodes[0].rightValue.formatToWGSL(context, 0);
-        }
-        else if (this.nodes.length > 0 &&
-            this.nodes[0] instanceof SN_Expression &&
-            this.nodes[0].nodes[0] instanceof SN_BinaryOperation) {
-            result +=
-                " = " + this.nodes[0].nodes[0].rightValue.formatToWGSL(context, 0);
-        }
-        else if (this.nodes.length > 0 &&
-            this.nodes[0] instanceof SN_Declaration) {
-            result += ";\r\n";
-            for (let item of this.nodes) {
-                result += item.formatToWGSL(context, depth) + ";\r\n";
-            }
-        }
-        else {
-            result += ";\r\n";
-        }
-        return result;
-    }
-}
-/**
- * @internal
- * Statement node: for
- * @group GFX
- */
-export class SN_ForLoop extends StatementNode {
-    constructor(expression1, condition, expression2, loopBody) {
-        super();
-        this.expression1 = expression1;
-        this.condition = condition;
-        this.expression2 = expression2;
-        this.loopBody = loopBody;
-    }
-    static parse(r) {
-        if (r.peekToken(0).Type == TokenType.FOR &&
-            r.peekToken(1).Type == TokenType.LEFTSAMLL) {
-            r.skipToken(2);
-            let expression1;
-            if (r.peekToken(0).Type == TokenType.SEMICOLON) {
-                r.skipToken(1);
-                expression1 = new SN_Expression();
-            }
-            else if (r.peekToken(0).isDataType() &&
-                r.peekToken(1).Type == TokenType.IDENT &&
-                r.peekToken(2).Type == TokenType.ASSIGN) {
-                expression1 = new SN_Declaration(r.peekToken(0).Literal, r.peekToken(1).Literal);
-                r.skipToken(1);
-                expression1.addNode(SN_Expression.parse(r));
-                if (r.peekToken(0).Type == TokenType.SEMICOLON) {
-                    r.skipToken(1);
-                }
-            }
-            else {
-                expression1 = SN_Expression.parse(r);
-                if (r.peekToken(0).Type == TokenType.SEMICOLON) {
-                    r.skipToken(1);
-                }
-            }
-            let condition;
-            if (r.peekToken(0).Type == TokenType.SEMICOLON) {
-                r.skipToken(1);
-                condition = new SN_Expression();
-            }
-            else {
-                condition = SN_Expression.parse(r);
-                if (r.peekToken(0).Type == TokenType.SEMICOLON) {
-                    r.skipToken(1);
-                }
-            }
-            let expression2;
-            if (r.peekToken(0).Type == TokenType.SEMICOLON) {
-                r.skipToken(1);
-                expression2 = new SN_Expression();
-            }
-            else {
-                expression2 = SN_Expression.parse(r);
-                if (r.peekToken(0).Type == TokenType.SEMICOLON) {
-                    r.skipToken(1);
-                }
-            }
-            if (r.peekToken(0).Type == TokenType.RIGHTSAMLL) {
-                r.skipToken(1);
-            }
-            let loopBody;
-            if (r.peekToken(0).Type == TokenType.LEFTBIG) {
-                loopBody = SN_CodeBlock.parse(r);
-            }
-            else {
-                loopBody = new SN_CodeBlock();
-            }
-            return new SN_ForLoop(expression1, condition, expression2, loopBody);
-        }
-        throw "Error parsing for loop: Unexpected character";
-    }
-    formatToWGSL(context, depth) {
-        let result = "";
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        result += prefix + "for (";
-        result += this.expression1.formatToWGSL(context, 0) + "; ";
-        result += this.condition.formatToWGSL(context, 0) + "; ";
-        result += this.expression2.formatToWGSL(context, 0) + ")";
-        result += " { \r\n";
-        for (let item of this.loopBody.nodes) {
-            result += item.formatToWGSL(context, depth + 1);
-            if (!(item instanceof SN_IFBranch) &&
-                !(item instanceof SN_WhileLoop) &&
-                !(item instanceof SN_ForLoop)) {
-                result += ";\r\n";
-            }
-        }
-        result += prefix + "} \r\n";
-        return result;
-    }
-}
-/**
- * @internal
- * Statement node: while
- * @group GFX
- */
-export class SN_WhileLoop extends StatementNode {
-    constructor(condition, loopBody) {
-        super();
-        this.conditionExpr = condition;
-        this.loopBody = loopBody;
-    }
-    static parse(r) {
-        if (r.peekToken(0).Type == TokenType.WHILE) {
-            r.skipToken(1);
-            if (r.peekToken(0).Type == TokenType.LEFTSAMLL) {
-                r.skipToken(1);
-            }
-            let condition = SN_Expression.parse(r);
-            if (r.peekToken(0).Type == TokenType.RIGHTSAMLL) {
-                r.skipToken(1);
-            }
-            let loopBody = SN_CodeBlock.parse(r);
-            return new SN_WhileLoop(condition, loopBody);
-        }
-        throw "Error parsing while loop: Unexpected character";
-    }
-    formatToWGSL(context, depth) {
-        let result = "";
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        result += prefix + "loop {\r\n";
-        result +=
-            prefix +
-                "    if (" +
-                this.conditionExpr.formatToWGSL(context, 0) +
-                ") { break; }\r\n\r\n";
-        for (let item of this.loopBody.nodes) {
-            result += item.formatToWGSL(context, depth + 1);
-            if (!(item instanceof SN_IFBranch) &&
-                !(item instanceof SN_WhileLoop) &&
-                !(item instanceof SN_ForLoop)) {
-                result += ";\r\n";
-            }
-        }
-        result += prefix + "}\r\n";
-        return result;
-    }
-}
-/**
- * @internal
- * Statement node: do-while
- * @group GFX
- */
-export class SN_DoWhileLoop extends StatementNode {
-    constructor() {
-        super();
-    }
-}
-/**
- * @internal
- * Statement node: if
- * @group GFX
- */
-export class SN_IFBranch extends StatementNode {
-    constructor(condition, trueBranch, falseBranch) {
-        super();
-        this.conditionExpr = condition;
-        this.trueBranch = trueBranch;
-        this.falseBranch = falseBranch;
-    }
-    static parse(r) {
-        if (r.peekToken(0).Type == TokenType.IF) {
-            r.skipToken(1);
-            if (r.peekToken(0).Type == TokenType.LEFTSAMLL) {
-                r.skipToken(1);
-            }
-            let condition = SN_Expression.parse(r);
-            let trueBranch;
-            let falseBranch = new SN_CodeBlock();
-            if (r.peekToken(0).Type == TokenType.RIGHTSAMLL) {
-                r.skipToken(1);
-            }
-            if (r.peekToken(0).Type == TokenType.LEFTBIG) {
-                trueBranch = SN_CodeBlock.parse(r);
-            }
-            else {
-                trueBranch = new SN_CodeBlock();
-                if (r.peekToken(0).Type == TokenType.RETURN) {
-                    trueBranch.addNode(SN_Return.parse(r));
-                }
-                else {
-                    trueBranch.addNode(SN_Expression.parse(r));
-                }
-            }
-            if (r.peekToken(0).Type == TokenType.ELSE) {
-                r.skipToken(1);
-                if (r.peekToken(0).Type == TokenType.LEFTBIG) {
-                    falseBranch = SN_CodeBlock.parse(r);
-                }
-                else
-                    throw "not impl";
-            }
-            return new SN_IFBranch(condition, trueBranch, falseBranch);
-        }
-        throw "Error parsing IF branch statement: Unexpected character";
-    }
-    formatToWGSL(context, depth) {
-        let resultl = "";
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        resultl +=
-            prefix + "if (" + this.conditionExpr.formatToWGSL(context, 0) + ") {\r\n";
-        for (let item of this.trueBranch.nodes) {
-            resultl += item.formatToWGSL(context, depth + 1) + ";\r\n";
-        }
-        if (this.falseBranch.nodes.length > 0) {
-            resultl += prefix + "} else {\r\n";
-            for (let item of this.falseBranch.nodes) {
-                resultl += item.formatToWGSL(context, depth + 1) + ";\r\n";
-            }
-        }
-        resultl += prefix + "}\r\n";
-        return resultl;
-    }
-}
-/**
- * @internal
- * Statement node: expression
- * @group GFX
- */
-export class SN_Expression extends StatementNode {
-    constructor() {
-        super();
-    }
-    static parse(r) {
-        let opStack = new Array();
-        let valueStack = new Array();
-        let nSamllCount = 0;
-        while (r.peekToken(0).Type != TokenType.EOF) {
-            let currToken = r.peekToken(0);
-            if (currToken.Type == TokenType.SEMICOLON ||
-                currToken.Type == TokenType.RIGHTMEDI) {
-                // r.SkipToken(1);
-                break;
-            }
-            if (currToken.Type == TokenType.COMMA ||
-                currToken.Type == TokenType.COLON ||
-                currToken.Type == TokenType.RIGHTBIG) {
-                break;
-            }
-            if (!currToken.isOperation()) {
-                if (currToken.Type == TokenType.LITERAL) {
-                    valueStack.push(new SN_Constant(currToken.Literal));
-                    r.skipToken(1);
-                    continue;
-                }
-                else if (currToken.Type == TokenType.LEFTSAMLL) {
-                    nSamllCount++;
-                    opStack.push(currToken);
-                    r.skipToken(1);
-                    continue;
-                }
-                else if (currToken.Type == TokenType.RIGHTSAMLL) {
-                    if (nSamllCount <= 0) {
-                        break;
-                    }
-                    nSamllCount--;
-                    while (SN_Expression.unionOperation(opStack, valueStack))
-                        ;
-                    if (opStack[opStack.length - 1].Type == TokenType.LEFTSAMLL) {
-                        opStack.pop();
-                        let parenExpr = new SN_ParenExpression();
-                        parenExpr.addNode(valueStack.pop());
-                        valueStack.push(parenExpr);
-                    }
-                    r.skipToken(1);
-                    continue;
-                }
-                else if (currToken.Type == TokenType.IDENT) {
-                    // a++
-                    if (r.peekToken(1).Type == TokenType.INC ||
-                        r.peekToken(1).Type == TokenType.DEC) {
-                        let op = r.peekToken(1);
-                        let value = new SN_Identifier(currToken.Literal);
-                        valueStack.push(new SN_UnaryOperation(op, value, undefined));
-                        r.skipToken(2);
-                        continue;
-                    }
-                    // func(...)
-                    else if (r.peekToken(1).Type == TokenType.LEFTSAMLL) {
-                        valueStack.push(SN_FunctionCall.parse(r));
-                        continue;
-                    }
-                    // a.b
-                    else if (r.peekToken(1).Type == TokenType.DOT) {
-                        valueStack.push(SN_SelectOperation.parse(r));
-                        continue;
-                    }
-                    // a[xxx]
-                    else if (r.peekToken(1).Type == TokenType.LEFTMEDI) {
-                        valueStack.push(SN_IndexOperation.parse(r));
-                        continue;
-                    }
-                    valueStack.push(new SN_Identifier(currToken.Literal));
-                    r.skipToken(1);
-                    continue;
-                }
-                else {
-                    // type(...)
-                    if (currToken.isBuiltinType() &&
-                        r.peekToken(1).Type == TokenType.LEFTSAMLL) {
-                        valueStack.push(SN_FunctionCall.parse(r));
-                        continue;
-                    }
-                    // a += xxx
-                    if (currToken.isAssignOperation()) {
-                        let op = currToken;
-                        r.skipToken(1);
-                        let lValue = valueStack.pop();
-                        let rValue = SN_Expression.parse(r);
-                        valueStack.push(new SN_BinaryOperation(op, lValue, rValue));
-                        continue;
-                    }
-                    // { 1.0, 2.0, 3.0 }
-                    if (currToken.Type == TokenType.LEFTBIG &&
-                        (r.peekToken(1).Type == TokenType.LITERAL ||
-                            (r.peekToken(1).Type == TokenType.SUB &&
-                                r.peekToken(2).Type == TokenType.LITERAL))) {
-                        valueStack.push(SN_ArrayConstant.parse(r));
-                        continue;
-                    }
-                    // xx ? xx : xx
-                    if (currToken.Type == TokenType.QUEMARK) {
-                        if (opStack.length > 0) {
-                            let opToken = opStack[opStack.length - 1];
-                            if (opToken.nOperationPriorityLevel <=
-                                currToken.nOperationPriorityLevel) {
-                                SN_Expression.unionOperation(opStack, valueStack);
-                            }
-                        }
-                        r.skipToken(1);
-                        let a = valueStack.pop();
-                        let b = SN_Expression.parse(r);
-                        if (r.peekToken(0).Type == TokenType.COLON) {
-                            r.skipToken(1);
-                        }
-                        let c = SN_Expression.parse(r);
-                        valueStack.push(new SN_TernaryOperation(a, b, c));
-                        if (r.peekToken(-1).Type == TokenType.SEMICOLON) {
-                            break;
-                        }
-                        continue;
-                    }
-                    // xxx[xxx]
-                    if (currToken.Type == TokenType.LEFTMEDI) {
-                        r.skipToken(1);
-                        let indexValue = SN_Expression.parse(r);
-                        if (r.peekToken(0).Type == TokenType.RIGHTMEDI) {
-                            r.skipToken(1);
-                        }
-                        let lValue = valueStack.pop();
-                        valueStack.push(new SN_IndexOperation(lValue, indexValue));
-                        continue;
-                    }
-                    throw "An unexpected character";
-                }
-            }
-            else if (currToken.isOperation()) {
-                // ++a, --a
-                if (currToken.Type == TokenType.INC ||
-                    currToken.Type == TokenType.DEC) {
-                    let op = currToken;
-                    r.skipToken(1);
-                    let value = SN_Expression.parse(r);
-                    valueStack.push(new SN_UnaryOperation(op, undefined, value));
-                    continue;
-                }
-                else if (opStack.length > 0) {
-                    let opToken = opStack[opStack.length - 1];
-                    if (opToken.nOperationPriorityLevel <= currToken.nOperationPriorityLevel) {
-                        SN_Expression.unionOperation(opStack, valueStack);
-                    }
-                    else if (opStack.length > 0 &&
-                        opStack[opStack.length - 1].Literal == "-") {
-                        let op = opStack.pop();
-                        let v1 = valueStack.pop();
-                        valueStack.push(new SN_UnaryOperation(op, undefined, v1));
-                    }
-                }
-                opStack.push(currToken);
-                r.skipToken(1);
-            }
-        }
-        while (opStack.length > 0 &&
-            SN_Expression.unionOperation(opStack, valueStack))
-            ;
-        if (opStack.length <= 0 && valueStack.length == 1) {
-            let expr = new SN_Expression();
-            expr.addNode(valueStack.pop());
-            return expr;
-        }
-        throw ("Error parsing expression: Unexpected character(" +
-            r.peekToken(0).Literal +
-            ")");
-    }
-    formatToWGSL(context, depth) {
-        return this.nodes[0].formatToWGSL(context, depth);
-    }
-    static unionOperation(opStack, valueStack) {
-        if (opStack.length < 0 || valueStack.length < 2) {
-            if (opStack.length > 0 && opStack[opStack.length - 1].Literal == "-") {
-                let op = opStack.pop();
-                let v1 = valueStack.pop();
-                valueStack.push(new SN_UnaryOperation(op, undefined, v1));
-                return true;
-            }
-            return false;
-        }
-        if (opStack[opStack.length - 1].isOperation()) {
-            let v2 = valueStack.pop();
-            let op = opStack.pop();
-            let v1 = valueStack.pop();
-            if (op.Type == TokenType.DOT) {
-                valueStack.push(new SN_SelectOperation(v1, v2));
-            }
-            else {
-                valueStack.push(new SN_BinaryOperation(op, v1, v2));
-            }
-            return true;
-        }
-        return false;
-    }
-}
-/**
- * @internal
- * Statement node: Paren expression
- * @group GFX
- */
-export class SN_ParenExpression extends StatementNode {
-    constructor() {
-        super();
-    }
-    formatToWGSL(context, depth) {
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        let result = prefix + "(" + this.nodes[0].formatToWGSL(context, 0) + ")";
-        return result;
-    }
-}
-/**
- * @internal
- * Statement node: identifier
- * @group GFX
- */
-export class SN_Identifier extends StatementNode {
-    constructor(name) {
-        super();
-        this.name = name;
-    }
-    formatToWGSL(context, depth) {
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        return prefix + context.findIdentifier(this.name);
-    }
-}
-/**
- * @internal
- * Statement node: constant
- * @group GFX
- */
-export class SN_Constant extends StatementNode {
-    constructor(value) {
-        super();
-        this.value = value;
-    }
-    static parse(r) {
-        let firstToken = r.peekToken(0);
-        // -1
-        if (firstToken.Type == TokenType.SUB &&
-            r.peekToken(1).Type == TokenType.LITERAL) {
-            let result = new SN_Constant("-" + r.peekToken(1).Literal);
-            r.skipToken(2);
-            return result;
-        }
-        // 1
-        else if (firstToken.Type == TokenType.LITERAL) {
-            let result = new SN_Constant(firstToken.Literal);
-            r.skipToken(1);
-            return result;
-        }
-        throw ("Error parsing literal constants: Unexpected characters(" +
-            firstToken.Literal +
-            ")");
-    }
-    formatToWGSL(context, depth) {
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        return prefix + this.value;
-    }
-}
-/**
- * @internal
- * Statement node: array constant
- * @group GFX
- */
-export class SN_ArrayConstant extends SN_Constant {
-    constructor(value) {
-        super("");
-        this.arrayValue = value;
-    }
-    static parse(r) {
-        if (
-        // { 1, 2, 3, 4 }
-        (r.peekToken(0).Type == TokenType.LEFTBIG &&
-            r.peekToken(1).Type == TokenType.LITERAL) ||
-            // { -1, 2, 3, 4 }
-            (r.peekToken(0).Type == TokenType.LEFTBIG &&
-                r.peekToken(1).Type == TokenType.SUB &&
-                r.peekToken(2).Type == TokenType.LITERAL)) {
-            r.skipToken(1);
-            let arrayValue = [];
-            while (r.peekToken(0).Type != TokenType.RIGHTBIG) {
-                if (r.peekToken(0).Type == TokenType.LEFTSAMLL) {
-                    arrayValue.push(SN_ArrayConstant.parse(r));
-                    continue;
-                }
-                arrayValue.push(SN_Constant.parse(r));
-                if (r.peekToken(0).Type == TokenType.COMMA) {
-                    r.skipToken(1);
-                    continue;
-                }
-                else if (r.peekToken(0).Type == TokenType.RIGHTBIG) {
-                    r.skipToken(1);
-                    break;
-                }
-                else
-                    throw "Error parsing array constants: Unexpected characters";
-            }
-            return new SN_ArrayConstant(arrayValue);
-        }
-        throw "Error parsing array constants: Unexpected characters";
-    }
-    formatToWGSL(context, depth) {
-        let result = "";
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        if (this.arrayValue[0].value.includes(".")) {
-            result +=
-                prefix + "array<f32, " + this.arrayValue.length.toString() + ">(";
-        }
-        else {
-            result +=
-                prefix + "array<i32, " + this.arrayValue.length.toString() + ">(";
-        }
-        for (let i = 0; i < this.arrayValue.length; i++) {
-            if (i > 0) {
-                result += ", ";
-            }
-            result += this.arrayValue[i].formatToWGSL(context, 0);
-        }
-        result += ")";
-        return result;
-    }
-}
-/**
- * @internal
- * Statement node: process control(break)
- * @group GFX
- */
-export class SN_Break extends StatementNode {
-    constructor() {
-        super();
-    }
-}
-/**
- * @internal
- * Statement node: process control(discard)
- * @group GFX
- */
-export class SN_Discard extends StatementNode {
-    constructor() {
-        super();
-    }
-}
-/**
- * @internal
- * Statement node: process control(continue)
- * @group GFX
- */
-export class SN_Continue extends StatementNode {
-    constructor() {
-        super();
-    }
-    static parse(r) {
-        if (r.peekToken(0).Type == TokenType.CONTINUE &&
-            r.peekToken(1).Type == TokenType.SEMICOLON) {
-            r.skipToken(2);
-            return new SN_Continue();
-        }
-        throw "Error parsing continue: Unexpected character";
-    }
-    formatToWGSL(context, depth) {
-        let result = "";
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        result += prefix + "continue";
-        return result;
-    }
-}
-/**
- * @internal
- * Statement node: process control(return)
- * @group GFX
- */
-export class SN_Return extends StatementNode {
-    constructor(value) {
-        super();
-        this.value = value;
-    }
-    static parse(r) {
-        if (r.peekToken(0).Type == TokenType.RETURN) {
-            r.skipToken(1);
-            let expr = SN_Expression.parse(r);
-            if (r.peekToken(0).Type == TokenType.SEMICOLON) {
-                r.skipToken(1);
-            }
-            return new SN_Return(expr);
-        }
-        throw "Error parsing return expression: Unexpected character";
-    }
-    formatToWGSL(context, depth) {
-        let result = "";
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        result += prefix + "return " + this.value.formatToWGSL(context, 0);
-        return result;
-    }
-}
-/**
- * @internal
- * Statement node: unary operation
- * @group GFX
- */
-export class SN_UnaryOperation extends StatementNode {
-    constructor(op, lValue, rValue) {
-        super();
-        this.op = op;
-        this.leftValue = lValue;
-        this.rightValue = rValue;
-    }
-    formatToWGSL(context, depth) {
-        let result = "";
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        if (this.op.Literal == "++" || this.op.Literal == "--") {
-            if (this.leftValue != undefined) {
-                let lValue = this.leftValue.formatToWGSL(context, 0);
-                result +=
-                    prefix + lValue + " = " + lValue + " " + this.op.Literal[0] + " 1";
-            }
-            else {
-                let rValue = this.rightValue.formatToWGSL(context, 0);
-                result +=
-                    prefix + rValue + " = " + rValue + " " + this.op.Literal[0] + " 1";
-            }
-        }
-        else {
-            if (this.leftValue != undefined) {
-                result +=
-                    prefix + this.leftValue.formatToWGSL(context, 0) + this.op.Literal;
-            }
-            else {
-                result +=
-                    prefix + this.op.Literal + this.rightValue.formatToWGSL(context, 0);
-            }
-        }
-        return result;
-    }
-}
-/**
- * @internal
- * Statement node: binary operation
- * @group GFX
- */
-export class SN_BinaryOperation extends StatementNode {
-    constructor(op, lValue, rValue) {
-        super();
-        this.op = op;
-        this.leftValue = lValue;
-        this.rightValue = rValue;
-    }
-    formatToWGSL(context, depth) {
-        let result = "";
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        result +=
-            prefix +
-                this.leftValue.formatToWGSL(context, 0) +
-                " " +
-                this.op.Literal +
-                " " +
-                this.rightValue.formatToWGSL(context, 0);
-        return result;
-    }
-}
-/**
- * @internal
- * Statement node: ternary operation
- * @group GFX
- */
-export class SN_TernaryOperation extends StatementNode {
-    constructor(condition, expression1, expression2) {
-        super();
-        this.condition = condition;
-        this.expression1 = expression1;
-        this.expression2 = expression2;
-    }
-    static parse(r) {
-        throw "Error parsing ternary operation expression: Unexpected character";
-    }
-    formatToWGSL(context, depth) {
-        return "";
-    }
-}
-/**
- * @internal
- * Statement node: Expression of select(a.b)
- * @group GFX
- */
-export class SN_SelectOperation extends StatementNode {
-    constructor(lValue, rValue) {
-        super();
-        this.leftValue = lValue;
-        this.rightValue = rValue;
-    }
-    static parse(r) {
-        if (r.peekToken(0).Type == TokenType.IDENT &&
-            r.peekToken(1).Type == TokenType.DOT &&
-            r.peekToken(2).Type == TokenType.IDENT) {
-            let lValue = new SN_Identifier(r.peekToken(0).Literal);
-            let rValue = new SN_Identifier(r.peekToken(2).Literal);
-            r.skipToken(3);
-            return new SN_SelectOperation(lValue, rValue);
-        }
-        throw "Error parsing selection expression: Unexpected character";
-    }
-    formatToWGSL(context, depth) {
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        return (prefix +
-            this.leftValue.formatToWGSL(context, 0) +
-            "." +
-            this.rightValue.formatToWGSL(context, 0));
-    }
-}
-/**
- * @internal
- * Statement node: Expression of index(a[b])
- * @group GFX
- */
-export class SN_IndexOperation extends StatementNode {
-    constructor(lValue, indexValue) {
-        super();
-        this.leftValue = lValue;
-        this.indexValue = indexValue;
-    }
-    static parse(r) {
-        if (r.peekToken(0).Type == TokenType.IDENT &&
-            r.peekToken(1).Type == TokenType.LEFTMEDI) {
-            let lValue = new SN_Identifier(r.peekToken(0).Literal);
-            r.skipToken(2);
-            let indexValue = SN_Expression.parse(r);
-            if (r.peekToken(0).Type == TokenType.RIGHTMEDI) {
-                r.skipToken(1);
-            }
-            let result = new SN_IndexOperation(lValue, indexValue);
-            while (r.peekToken(0).Type == TokenType.LEFTMEDI) {
-                r.skipToken(1);
-                indexValue = SN_Expression.parse(r);
-                if (r.peekToken(0).Type == TokenType.RIGHTMEDI) {
-                    r.skipToken(1);
-                }
-                result = new SN_IndexOperation(result, indexValue);
-            }
-            return result;
-        }
-        throw "Error parsing index expression: Unexpected character";
-    }
-    formatToWGSL(context, depth) {
-        let prefix = depth <= 0 ? "" : "    ".repeat(depth);
-        return (prefix +
-            this.leftValue.formatToWGSL(context, 0) +
-            "[" +
-            this.indexValue.formatToWGSL(context, 0) +
-            "]");
-    }
-}
-/**
- * @internal
- * Statement node: code block
- * @group GFX
- */
-export class SN_CodeBlock extends StatementNode {
-    constructor() {
-        super();
-    }
-    static parse(r) {
-        if (r.peekToken(0).Type == TokenType.LEFTBIG) {
-            r.skipToken(1);
-            let result = new SN_CodeBlock();
-            for (let count = 1; count > 0 && r.peekToken(0).Type != TokenType.EOF;) {
-                let currToken = r.peekToken(0);
-                if (currToken.Type == TokenType.LEFTBIG) {
-                    count++;
-                    r.skipToken(1);
-                    continue;
-                }
-                if (currToken.Type == TokenType.RIGHTBIG) {
-                    count--;
-                    r.skipToken(1);
-                    continue;
-                }
-                /**
-                 * nop
-                 */
-                if (currToken.Type == TokenType.SEMICOLON) {
-                    r.skipToken(1);
-                    continue;
-                }
-                /**
-                 * Declaration of variables
-                 */
-                if (currToken.isDataType() && r.peekToken(1).Type == TokenType.IDENT) {
-                    result.addNode(SN_Declaration.parse(r));
-                    continue;
-                }
-                /**
-                 * Declaration of variables
-                 */
-                if (currToken.Type == TokenType.CONST &&
-                    r.peekToken(1).isDataType() &&
-                    r.peekToken(2).Type == TokenType.IDENT) {
-                    result.addNode(SN_Declaration.parse(r));
-                    continue;
-                }
-                else if (
-                /**
-                 * assignment expression
-                 * a = ...;
-                 */
-                currToken.Type == TokenType.IDENT &&
-                    r.peekToken(1).Type == TokenType.ASSIGN) {
-                    result.addNode(SN_Expression.parse(r));
-                    if (r.peekToken(0).Type == TokenType.SEMICOLON) {
-                        r.skipToken(1);
-                    }
-                    continue;
-                }
-                else if (
-                /**
-                 * Expression of index
-                 * a[...]
-                 */
-                currToken.Type == TokenType.IDENT &&
-                    r.peekToken(1).Type == TokenType.LEFTMEDI) {
-                    let indexOperation = SN_IndexOperation.parse(r);
-                    // a[...] = xxx;
-                    if (r.peekToken(0).Type == TokenType.ASSIGN) {
-                        let op = r.peekToken(0);
-                        r.skipToken(1);
-                        let rValue = SN_Expression.parse(r);
-                        if (r.peekToken(0).Type == TokenType.RIGHTMEDI) {
-                            r.skipToken(1);
-                        }
-                        result.addNode(new SN_BinaryOperation(op, indexOperation, rValue));
-                        continue;
-                    }
-                    result.addNode(indexOperation);
-                    continue;
-                }
-                else if (
-                /**
-                 * Expression of choice
-                 * a.b
-                 */
-                currToken.Type == TokenType.IDENT &&
-                    r.peekToken(1).Type == TokenType.DOT) {
-                    let expr = SN_Expression.parse(r);
-                    result.addNode(expr);
-                    continue;
-                }
-                else if (
-                /**
-                 * Assignment operation expression
-                 * a += ...;
-                 */
-                currToken.Type == TokenType.IDENT &&
-                    r.peekToken(1).isAssignOperation()) {
-                    let op = r.peekToken(1);
-                    let lValue = new SN_Identifier(currToken.Literal);
-                    r.skipToken(2);
-                    let rValue = SN_Expression.parse(r);
-                    if (r.peekToken(0).Type == TokenType.SEMICOLON) {
-                        r.skipToken(1);
-                    }
-                    result.addNode(new SN_BinaryOperation(op, lValue, rValue));
-                    continue;
-                }
-                else if (
-                /**
-                 * After the increase, after the decrease
-                 * a++;
-                 */
-                currToken.Type == TokenType.IDENT &&
-                    (r.peekToken(1).Type == TokenType.INC ||
-                        r.peekToken(1).Type == TokenType.DEC) &&
-                    r.peekToken(2).Type == TokenType.SEMICOLON) {
-                    let op = r.peekToken(1);
-                    result.addNode(new SN_UnaryOperation(op, new SN_Identifier(currToken.Literal), undefined));
-                    r.skipToken(3);
-                    continue;
-                }
-                else if (currToken.Type == TokenType.RETURN) {
-                    /**
-                     * return
-                     */
-                    result.addNode(SN_Return.parse(r));
-                    continue;
-                }
-                else if (currToken.Type == TokenType.CONTINUE) {
-                    /**
-                     * continue
-                     */
-                    result.addNode(SN_Continue.parse(r));
-                    continue;
-                }
-                else if (currToken.Type == TokenType.WHILE) {
-                    /**
-                     * while
-                     */
-                    result.addNode(SN_WhileLoop.parse(r));
-                    continue;
-                }
-                else if (currToken.Type == TokenType.FOR) {
-                    /**
-                     * for
-                     */
-                    result.addNode(SN_ForLoop.parse(r));
-                    continue;
-                }
-                else if (currToken.Type == TokenType.IF) {
-                    /**
-                     * if
-                     */
-                    result.addNode(SN_IFBranch.parse(r));
-                    continue;
-                }
-                else if (
-                /**
-                 * function call
-                 */
-                currToken.Type == TokenType.IDENT &&
-                    r.peekToken(1).Type == TokenType.LEFTSAMLL) {
-                    result.addNode(SN_FunctionCall.parse(r));
-                    if (r.peekToken(0).Type == TokenType.SEMICOLON) {
-                        r.skipToken(0);
-                    }
-                    continue;
-                }
-                throw ("Error parsing block: Unexpected symbol(" + currToken.Literal + ")");
-            }
-            return result;
-        }
-        throw "Error parsing block: Unexpected symbol";
-    }
-}
-/**
- * @internal
- * Statement node: precision
- * @group GFX
- */
-export class SN_Precision extends StatementNode {
-    constructor(qualifier, type) {
-        super();
-        this.type = type;
-        this.qualifier = qualifier;
-    }
-    static parse(r) {
-        if (r.peekToken(0).Type == TokenType.PRECISION &&
-            r.peekToken(1).Type == TokenType.IDENT &&
-            r.peekToken(2).isBuiltinType()) {
-            let result = new SN_Precision(r.peekToken(1).Literal, r.peekToken(2).Literal);
-            r.skipToken(3);
-            if (r.peekToken(0).Type == TokenType.SEMICOLON) {
-                r.skipToken(1);
-            }
-            return result;
-        }
-        throw "Error parsing precision qualifier: Unexpected character";
-    }
-    formatToWGSL(context, depth) {
-        return "";
-    }
-}
-/**
- * @internal
- * Statement node: layout
- * @group GFX
- */
-export class SN_Layout extends StatementNode {
-    constructor() {
-        super();
-        this.scope = "";
-        this.qualifier = new Map();
-    }
-    addQualifier(name, value = "") {
-        this.qualifier.set(name, value);
-    }
-    static parse(r) {
-        if (r.peekToken(0).Type == TokenType.LAYOUT &&
-            r.peekToken(1).Type == TokenType.LEFTSAMLL) {
-            let result = new SN_Layout();
-            r.skipToken(2);
-            do {
-                let currToken = r.peekToken(0);
-                if (currToken.Type == TokenType.IDENT) {
-                    if (r.peekToken(1).Type == TokenType.ASSIGN &&
-                        r.peekToken(2).Type == TokenType.LITERAL) {
-                        let name = r.peekToken(0).Literal;
-                        let value = r.peekToken(2).Literal;
-                        result.addQualifier(name, value);
-                        r.skipToken(3);
-                        if (r.peekToken(0).Type == TokenType.COMMA) {
-                            r.skipToken(1);
-                            continue;
-                        }
-                        let token = r.peekToken(0);
-                        token.Line = 0;
-                    }
-                    else if (r.peekToken(1).Type == TokenType.RIGHTSAMLL) {
-                        let name = r.peekToken(0).Literal;
-                        result.addQualifier(name, "");
-                        r.skipToken(1);
-                        break;
-                    }
-                    else if (r.peekToken(1).Type == TokenType.COMMA) {
-                        let name = r.peekToken(0).Literal;
-                        result.addQualifier(name, "");
-                        r.skipToken(2);
-                        continue;
-                    }
-                }
-            } while (r.peekToken(0).Type != TokenType.RIGHTSAMLL);
-            if (r.peekToken(0).Type == TokenType.RIGHTSAMLL) {
-                r.skipToken(1);
-            }
-            // Scope of resolution
-            result.scope = r.peekToken(0).Literal;
-            r.skipToken(1);
-            // Empty qualifier
-            if (r.peekToken(0).Type == TokenType.SEMICOLON) {
-                r.skipToken(1);
-                return result;
-            }
-            // Built-in type
-            else if (r.peekToken(0).isBuiltinType() &&
-                r.peekToken(1).Type == TokenType.IDENT &&
-                r.peekToken(2).Type == TokenType.SEMICOLON) {
-                let node = new SN_Declaration(r.peekToken(0).Literal, r.peekToken(1).Literal);
-                result.addNode(node);
-                r.skipToken(3);
-                return result;
-            }
-            // structure type
-            else if (r.peekToken(0).Type == TokenType.IDENT &&
-                r.peekToken(1).Type == TokenType.LEFTBIG) {
-                let structNode = SN_Struct.parse(r);
-                result.addNode(structNode);
-                if (r.peekToken(0).Type == TokenType.IDENT &&
-                    r.peekToken(1).Type == TokenType.SEMICOLON) {
-                    structNode.addNode(new SN_Declaration(structNode.name, r.peekToken(0).Literal));
-                    r.skipToken(2);
-                }
-                return result;
-            }
-            else
-                throw ("Error parsing layout qualifier type: Unexpected symbol(" +
-                    r.peekToken(0).Literal +
-                    ")");
-        }
-        throw "Error parsing layout qualifier: Unexpected symbol";
-    }
-    formatToWGSL(context, depth) {
-        let result = "";
-        if (this.qualifier.size == 1 && this.qualifier.has("location")) {
-            result += "@location(" + this.qualifier.get("location") + ") ";
-        }
-        else if (this.qualifier.size == 2 &&
-            this.qualifier.has("set") &&
-            this.qualifier.has("binding")) {
-            result +=
-                "@group(" +
-                    this.qualifier.get("set") +
-                    ") @binding(" +
-                    this.qualifier.get("binding") +
-                    ") ";
-        }
-        else if (this.qualifier.size >= 1 && this.qualifier.has("binding")) {
-            result += "@group(0) @binding(" + this.qualifier.get("binding") + ") ";
-        }
-        else if (this.qualifier.size == 1 &&
-            this.qualifier.has("push_constant")) {
-            result += "@push_constant ";
-        }
-        else if (this.qualifier.size >= 1 && this.qualifier.has("local_size_x")) {
-            result += "@workgroup_size(";
-            result += this.qualifier.get("local_size_x") + ", ";
-            result += this.qualifier.has("local_size_y")
-                ? this.qualifier.get("local_size_y") + ", "
-                : "1, ";
-            result += this.qualifier.has("local_size_z")
-                ? this.qualifier.get("local_size_z") + ""
-                : "1";
-            result += ")";
-        }
-        else if (this.nodes.length <= 0) {
-            return "";
-        }
-        let item = this.nodes[0];
-        if (item instanceof SN_Declaration) {
-            switch (item.type) {
-                case "sampler":
-                case "texture2D":
-                    result += "var ";
-                    break;
-                default:
-                    if (this.scope == "buffer") {
-                        if (context.stage == "compute") {
-                            result += "var<storage, read_write> ";
-                        }
-                        else {
-                            result += "var<storage, read> ";
-                        }
-                    }
-                    else {
-                        result += "var<" + this.scope + "> ";
-                    }
-                    break;
-            }
-            context.addIdentifier(item.name, item.name);
-            result += item.name + ": " + toWGSLType(item.type) + ";\r\n";
-        }
-        else if (item instanceof SN_Struct) {
-            if (this.scope == "buffer") {
-                if (context.stage == "compute") {
-                    result += "var<storage, read_write> ";
-                }
-                else {
-                    result += "var<storage, read> ";
-                }
-            }
-            else {
-                result += "var<" + this.scope + "> ";
-            }
-            if (item.nodes.length <= 0) {
-                let rename = "unif" + context.layoutUniformCount.toString();
-                while (context.hasIdentifier(rename)) {
-                    context.layoutUniformCount++;
-                    rename = "unif" + context.layoutUniformCount.toString();
-                }
-                for (let field of item.fields) {
-                    context.addIdentifier(field.name, rename + "." + field.name);
-                }
-                result += rename + ": " + item.name + ";\r\n";
-                context.layoutUniformCount++;
-            }
-            else {
-                let declaration = item.nodes[0];
-                result += declaration.name + ": " + declaration.type + ";\r\n";
-            }
-            return result;
-        }
-        return result;
-    }
-}
-/**
- * @internal
- * @param type
- * @returns
- */
-function toWGSLType(type) {
-    switch (type) {
-        case "int":
-            return "i32";
-        case "int[]":
-            return "array<i32>";
-        case "uint":
-            return "u32";
-        case "uint[]":
-            return "array<u32>";
-        case "float":
-            return "f32";
-        case "float[]":
-            return "array<f32>";
-        case "vec2":
-            return "vec2<f32>";
-        case "vec3":
-            return "vec3<f32>";
-        case "vec4":
-            return "vec4<f32>";
-        case "vec2[]":
-            return "array<vec2<f32>>";
-        case "vec3[]":
-            return "array<vec3<f32>>";
-        case "vec4[]":
-            return "array<vec4<f32>>";
-        case "ivec2":
-            return "vec2<i32>";
-        case "ivec3":
-            return "vec3<i32>";
-        case "ivec4":
-            return "vec4<i32>";
-        case "ivec2[]":
-            return "array<vec2<i32>>";
-        case "ivec3[]":
-            return "array<vec3<i32>>";
-        case "ivec4[]":
-            return "array<vec4<i32>>";
-        case "mat2":
-            return "mat2x2<f32>";
-        case "mat2x2":
-            return "mat2x2<f32>";
-        case "mat2x3":
-            return "mat2x3<f32>";
-        case "mat2x4":
-            return "mat2x4<f32>";
-        case "mat2[]":
-            return "array<mat2x2<f32>>";
-        case "mat2x2[]":
-            return "array<mat2x2<f32>>";
-        case "mat2x3[]":
-            return "array<mat2x3<f32>>";
-        case "mat2x4[]":
-            return "array<mat2x4<f32>>";
-        case "mat3":
-            return "mat3x3<f32>";
-        case "mat3x2":
-            return "mat3x2<f32>";
-        case "mat3x3":
-            return "mat3x3<f32>";
-        case "mat3x4":
-            return "mat3x4<f32>";
-        case "mat3[]":
-            return "array<mat3x3<f32>>";
-        case "mat3x2[]":
-            return "array<mat3x2<f32>>";
-        case "mat3x3[]":
-            return "array<mat3x3<f32>>";
-        case "mat3x4[]":
-            return "array<mat3x4<f32>>";
-        case "mat4":
-            return "mat4x4<f32>";
-        case "mat4x2":
-            return "mat4x2<f32>";
-        case "mat4x3":
-            return "mat4x3<f32>";
-        case "mat4x4":
-            return "mat4x4<f32>";
-        case "mat4[]":
-            return "array<mat4x4<f32>>";
-        case "mat4x2[]":
-            return "array<mat4x2<f32>>";
-        case "mat4x3[]":
-            return "array<mat4x3<f32>>";
-        case "mat4x4[]":
-            return "array<mat4x4<f32>>";
-        case "texture2D":
-            return "texture_2d<f32>";
-    }
-    return type;
-}