@rings-webgpu/core 1.0.0 → 1.0.2

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

@@ -0,0 +1,50 @@
+import { GLSLSyntax } from "./GLSLSyntax";
+import { ShaderConverterResult } from "./ShaderConverter";
+import { SN_Layout, StatementNode } from "./StatementNode";
+/**
+ * @internal
+ * WGSLCode Translator
+ * @group GFX
+ */
+export declare class WGSLTranslator {
+    result: string;
+    ASTRoot: StatementNode;
+    protected _syntax: GLSLSyntax;
+    constructor(syntax: GLSLSyntax);
+    /**
+     * Generate WGSL code
+     * @returns WGSL code
+     */
+    generateWGSL(): ShaderConverterResult;
+}
+/**
+ * The translator context
+ * @internal
+ * @group GFX
+ */
+export declare class TranslatorContext {
+    protected _stage: string;
+    protected _builtinIn: Array<string>;
+    protected _builtinOut: Array<string>;
+    protected _layoutsIn: Array<SN_Layout>;
+    protected _layoutsOut: Array<SN_Layout>;
+    protected _layoutUniformCount: number;
+    protected _workGroupSize: SN_Layout;
+    protected _parentContext?: TranslatorContext;
+    protected _identifierEnv: Map<string, string>;
+    constructor(context?: TranslatorContext);
+    get stage(): string;
+    set stage(value: string);
+    get builtinIn(): Array<string>;
+    get builtinOut(): Array<string>;
+    get layoutsIn(): Array<SN_Layout>;
+    get layoutsOut(): Array<SN_Layout>;
+    get layoutUniformCount(): number;
+    set layoutUniformCount(value: number);
+    get workGroupSize(): SN_Layout;
+    set workGroupSize(value: SN_Layout);
+    get parentContext(): TranslatorContext | undefined;
+    findIdentifier(name: string): string;
+    addIdentifier(name: string, value: string): void;
+    hasIdentifier(name: string): boolean;
+}

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

@@ -0,0 +1,272 @@
+import { Reader } from "./Reader";
+import { ShaderAttributeInfo, ShaderConverterResult, ShaderUniformInfo, } from "./ShaderConverter";
+import { SN_Declaration, SN_Layout, SN_Struct, } from "./StatementNode";
+/**
+ * @internal
+ * WGSLCode Translator
+ * @group GFX
+ */
+export class WGSLTranslator {
+    constructor(syntax) {
+        this.result = "";
+        this._syntax = syntax;
+        this.ASTRoot = syntax.ASTRoot;
+    }
+    /**
+     * Generate WGSL code
+     * @returns WGSL code
+     */
+    generateWGSL() {
+        let context = new TranslatorContext();
+        var result = new ShaderConverterResult();
+        let layoutsBuffer = [];
+        let layoutsUniform = [];
+        let statements = [];
+        // Extract layout description
+        for (let item of this.ASTRoot.nodes) {
+            if (item instanceof SN_Layout) {
+                if (item.scope == "in") {
+                    if (item.nodes[0] instanceof SN_Declaration) {
+                        context.layoutsIn.push(item);
+                        let info = new ShaderAttributeInfo();
+                        info.name = item.nodes[0].name;
+                        info.type = item.nodes[0].type;
+                        info.locationID = Number.parseInt(item.qualifier.get("location"));
+                        result.inputAttribute.push(info);
+                    }
+                    else if (item.qualifier.has("local_size_x")) {
+                        context.workGroupSize = item;
+                    }
+                    else
+                        throw "not impl";
+                }
+                else if (item.scope == "out") {
+                    context.layoutsOut.push(item);
+                    if (item.nodes[0] instanceof SN_Declaration) {
+                        let info = new ShaderAttributeInfo();
+                        info.name = item.nodes[0].name;
+                        info.type = item.nodes[0].type;
+                        info.locationID = Number.parseInt(item.qualifier.get("location"));
+                        result.outputAttribute.push(info);
+                    }
+                    else
+                        throw "not impl";
+                }
+                else if (item.scope == "uniform") {
+                    layoutsUniform.push(item);
+                    if (item.nodes[0] instanceof SN_Declaration) {
+                        let info = new ShaderUniformInfo();
+                        info.name = item.nodes[0].name;
+                        info.type = item.nodes[0].type;
+                        info.setID = Number.parseInt(item.qualifier.get("set"));
+                        info.bindingID = Number.parseInt(item.qualifier.get("binding"));
+                        result.uniformInfo.push(info);
+                    }
+                    else if (item.nodes[0] instanceof SN_Struct) {
+                        let info = new ShaderUniformInfo();
+                        info.name = "unif" + result.uniformInfo.length.toString();
+                        info.type = item.nodes[0].name;
+                        info.setID = Number.parseInt(item.qualifier.get("set"));
+                        info.bindingID = Number.parseInt(item.qualifier.get("binding"));
+                        result.uniformInfo.push(info);
+                    }
+                    else
+                        throw "not impl";
+                }
+                else if (item.scope == "buffer") {
+                    layoutsBuffer.push(item);
+                }
+            }
+            else {
+                statements.push(item);
+            }
+        }
+        // Extracting built-in variables
+        context.stage = "fragment";
+        let position = 0;
+        let reader = new Reader("");
+        let source = this._syntax.lexer.source;
+        let unique = new Map();
+        while ((position = source.indexOf("gl_", position)) != -1) {
+            reader.reset(source.substring(position, position + 32));
+            reader.readChar();
+            let name = reader.readIdentifier();
+            position += name.length;
+            if (unique.has(name)) {
+                continue;
+            }
+            unique.set(name, name);
+            switch (name) {
+                case "gl_InstanceID":
+                    context.stage = "vertex";
+                    context.builtinIn.push("@builtin(instance_index) gl_InstanceID: u32");
+                    break;
+                case "gl_Position":
+                    context.stage = "vertex";
+                    context.builtinOut.push("@builtin(position) gl_Position: vec4<f32>");
+                    context.addIdentifier("gl_Position", "stout.gl_Position");
+                    break;
+                case "gl_VertexIndex":
+                    context.stage = "vertex";
+                    context.builtinIn.push("@builtin(vertex_index) gl_VertexIndex: u32");
+                    break;
+                case "gl_FrontFacing":
+                    context.stage = "fragment";
+                    context.builtinIn.push("@builtin(front_facing) gl_FrontFacing: bool");
+                    break;
+                case "gl_FragDepth":
+                    context.stage = "fragment";
+                    context.builtinOut.push("@builtin(frag_depth) gl_FragDepth: f32");
+                    context.addIdentifier("gl_FragDepth", "stout.gl_FragDepth");
+                    break;
+                case "gl_WorkGroupID":
+                    context.stage = "compute";
+                    context.builtinIn.push("@builtin(workgroup_id) gl_WorkGroupID: vec3<u32>");
+                    break;
+                case "gl_NumWorkGroups":
+                    context.stage = "compute";
+                    context.builtinIn.push("@builtin(num_workgroups) gl_NumWorkGroups: vec3<u32>");
+                    break;
+                case "gl_LocalInvocationID":
+                    context.stage = "compute";
+                    context.builtinIn.push("@builtin(local_invocation_id) gl_LocalInvocationID: vec3<u32>");
+                    break;
+                case "gl_LocalInvocationIndex":
+                    context.stage = "compute";
+                    context.builtinIn.push("@builtin(local_invocation_index) gl_LocalInvocationIndex: u32");
+                    break;
+                case "gl_GlobalInvocationID":
+                    context.stage = "compute";
+                    context.builtinIn.push("@builtin(global_invocation_id) gl_GlobalInvocationID: vec3<u32>");
+                    break;
+                default:
+                    throw "Unprocessed built-in variables: " + name;
+            }
+        }
+        // Translate to WGSL
+        for (let item of layoutsUniform) {
+            if (item.nodes[0] instanceof SN_Struct) {
+                result.sourceCode += item.nodes[0].formatToWGSL(context, 0);
+                result.sourceCode += "\r\n";
+            }
+        }
+        for (let item of layoutsUniform) {
+            result.sourceCode += item.formatToWGSL(context, 0);
+        }
+        result.sourceCode += "\r\n";
+        for (let item of layoutsBuffer) {
+            if (item.nodes[0] instanceof SN_Struct) {
+                result.sourceCode += item.nodes[0].formatToWGSL(context, 0);
+                result.sourceCode += "\r\n";
+            }
+        }
+        for (let item of layoutsBuffer) {
+            result.sourceCode += item.formatToWGSL(context, 0);
+        }
+        result.sourceCode += "\r\n";
+        for (let item of statements) {
+            result.sourceCode += item.formatToWGSL(context, 0);
+            if (item instanceof SN_Declaration) {
+                result.sourceCode += ";\r\n";
+            }
+        }
+        return result;
+    }
+}
+/**
+ * The translator context
+ * @internal
+ * @group GFX
+ */
+export class TranslatorContext {
+    constructor(context) {
+        this._stage = "fragment";
+        this._builtinIn = [];
+        this._builtinOut = [];
+        this._layoutsIn = [];
+        this._layoutsOut = [];
+        this._layoutUniformCount = 0;
+        this._workGroupSize = undefined;
+        this._identifierEnv = new Map();
+        this._parentContext = context;
+    }
+    get stage() {
+        if (this.parentContext != undefined) {
+            return this.parentContext.stage;
+        }
+        return this._stage;
+    }
+    set stage(value) {
+        if (this.parentContext != undefined) {
+            this.parentContext.stage = value;
+        }
+        this._stage = value;
+    }
+    get builtinIn() {
+        if (this.parentContext != undefined) {
+            return this.parentContext.builtinIn;
+        }
+        return this._builtinIn;
+    }
+    get builtinOut() {
+        if (this.parentContext != undefined) {
+            return this.parentContext.builtinOut;
+        }
+        return this._builtinOut;
+    }
+    get layoutsIn() {
+        if (this.parentContext != undefined) {
+            return this.parentContext.layoutsIn;
+        }
+        return this._layoutsIn;
+    }
+    get layoutsOut() {
+        if (this.parentContext != undefined) {
+            return this.parentContext.layoutsOut;
+        }
+        return this._layoutsOut;
+    }
+    get layoutUniformCount() {
+        if (this.parentContext != undefined) {
+            return this.parentContext.layoutUniformCount;
+        }
+        return this._layoutUniformCount;
+    }
+    set layoutUniformCount(value) {
+        if (this.parentContext != undefined) {
+            this.parentContext.layoutUniformCount = value;
+            return;
+        }
+        this._layoutUniformCount = value;
+    }
+    get workGroupSize() {
+        if (this.parentContext != undefined) {
+            return this.parentContext.workGroupSize;
+        }
+        return this._workGroupSize;
+    }
+    set workGroupSize(value) {
+        if (this.parentContext != undefined) {
+            this.parentContext.workGroupSize = value;
+        }
+        this._workGroupSize = value;
+    }
+    get parentContext() {
+        return this._parentContext;
+    }
+    findIdentifier(name) {
+        if (this._identifierEnv.has(name)) {
+            return this._identifierEnv.get(name);
+        }
+        if (this._parentContext != undefined) {
+            return this._parentContext.findIdentifier(name);
+        }
+        return name;
+    }
+    addIdentifier(name, value) {
+        this._identifierEnv.set(name, value);
+    }
+    hasIdentifier(name) {
+        return this._identifierEnv.has(name);
+    }
+}

package/dist/src/gfx/graphics/webGpu/shader/util/MorePassParser.d.ts

@@ -0,0 +1,25 @@
+export declare class MorePassShader {
+    name: string;
+    passMap: Map<string, PassShader[]>;
+}
+export declare class PassShader {
+    passType: string;
+    shaderState: Map<string, any>;
+    vertexShader: string;
+    fragmentShader: string;
+}
+export declare class MorePassParser {
+    protected static passKeyword: string;
+    protected static shaderKeyword: string;
+    protected static vertexKeyword: string;
+    protected static fragmentKeyword: string;
+    protected static passTypeKeyword: string;
+    static parser(code: string, defineValue: {
+        [name: string]: any;
+    }): MorePassShader;
+    protected static splitPassBlock(code: string): string[];
+    protected static parserPassBlock(code: string): PassShader;
+    protected static parserShaderState(passShader: PassShader, code: string): boolean;
+    protected static convertValue(str: string): number | boolean | string;
+    private static extractBlock;
+}

package/dist/src/gfx/graphics/webGpu/shader/util/MorePassParser.js

@@ -0,0 +1,134 @@
+import { Preprocessor } from "./Preprocessor";
+export class MorePassShader {
+    constructor() {
+        this.name = "";
+        this.passMap = new Map();
+    }
+}
+export class PassShader {
+    constructor() {
+        this.passType = "";
+        this.shaderState = new Map();
+        this.vertexShader = "";
+        this.fragmentShader = "";
+    }
+}
+export class MorePassParser {
+    static { this.passKeyword = "pass"; }
+    static { this.shaderKeyword = "Shader"; }
+    static { this.vertexKeyword = "vertex"; }
+    static { this.fragmentKeyword = "fragment"; }
+    static { this.passTypeKeyword = "PassType"; }
+    static parser(code, defineValue) {
+        code = Preprocessor.filterComment(code);
+        let result = new MorePassShader();
+        let index1 = code.indexOf(this.shaderKeyword);
+        let index2 = code.indexOf("{", index1);
+        let block = code
+            .substring(index1 + this.shaderKeyword.length, index2)
+            .trim();
+        result.name = block.substring(1, block.length - 1);
+        block = code.substring(code.indexOf("{") + 1, code.lastIndexOf("}"));
+        let passBlocks = this.splitPassBlock(block);
+        for (let passCode of passBlocks) {
+            let passShader = this.parserPassBlock(passCode);
+            let passshaderList;
+            if (result.passMap.has(passShader.passType)) {
+                passshaderList = result.passMap.get(passShader.passType);
+            }
+            else {
+                passshaderList = [];
+                result.passMap.set(passShader.passType, passshaderList);
+            }
+            passshaderList.push(passShader);
+            if (passShader.vertexShader.length > 0) {
+                passShader.vertexShader = Preprocessor.parse(passShader.vertexShader, defineValue);
+            }
+            if (passShader.fragmentShader.length > 0) {
+                passShader.fragmentShader = Preprocessor.parse(passShader.fragmentShader, defineValue);
+            }
+        }
+        return result;
+    }
+    static splitPassBlock(code) {
+        let offset = 0;
+        let result = [];
+        while (offset < code.length) {
+            let index = code.indexOf(this.passKeyword, offset);
+            if (index == -1) {
+                result.push(code.substring(offset));
+                break;
+            }
+            if (offset != 0) {
+                result.push(code.substring(offset, index));
+            }
+            offset = index + this.passKeyword.length;
+        }
+        return result;
+    }
+    static parserPassBlock(code) {
+        let passShader = new PassShader();
+        let index1 = code.indexOf(this.passTypeKeyword);
+        let index2 = code.indexOf('"', index1);
+        index1 = code.indexOf('"', index2 + 1);
+        passShader.passType = code.substring(index1 + 1, index2).trim();
+        this.parserShaderState(passShader, code);
+        index1 = code.indexOf(this.vertexKeyword);
+        if (index1 != -1) {
+            passShader.vertexShader = this.extractBlock(code.substring(index1 + this.vertexKeyword.length), "{", "}");
+        }
+        index1 = code.indexOf(this.fragmentKeyword);
+        if (index1 != -1) {
+            passShader.fragmentShader = this.extractBlock(code.substring(index1 + this.fragmentKeyword.length), "{", "}");
+        }
+        return passShader;
+    }
+    static parserShaderState(passShader, code) {
+        let indexL = code.indexOf("ShaderState");
+        if (indexL == -1)
+            return false;
+        indexL = code.indexOf("{", indexL);
+        let indexR = code.indexOf("}", indexL);
+        let codeBlock = code.substring(indexL + 1, indexR);
+        let fields = codeBlock.split(",");
+        for (let item of fields) {
+            let keyValue = item.split(":");
+            let key = keyValue[0].trim();
+            let value = this.convertValue(keyValue[1].trim());
+            passShader.shaderState.set(key, value);
+        }
+        return true;
+    }
+    static convertValue(str) {
+        if (str.length == 4 && str.toLowerCase() == "true")
+            return true;
+        else if (str.length == 5 && str.toLowerCase() == "false")
+            return false;
+        else if (str[0] == '"')
+            return str.substring(1, str.length - 1);
+        return Number.parseInt(str);
+    }
+    static extractBlock(str, leftStr, rightStr) {
+        let indexL = str.indexOf(leftStr);
+        if (indexL == -1) {
+            return "";
+        }
+        let depth = 0;
+        let indexR = 0;
+        str = str.substring(indexL);
+        for (let char of str) {
+            if (char == leftStr) {
+                depth++;
+            }
+            else if (char == rightStr) {
+                depth--;
+            }
+            if (depth <= 0) {
+                break;
+            }
+            indexR++;
+        }
+        let block = str.substring(1, indexR).trim();
+        return block;
+    }
+}

package/dist/src/gfx/graphics/webGpu/shader/util/Preprocessor.d.ts

@@ -0,0 +1,28 @@
+export declare class Preprocessor {
+    static parse(code: string, defineValue: {
+        [name: string]: any;
+    }): string;
+    static parseComputeShader(code: string, defineValue: {
+        [name: string]: any;
+    }): string;
+    protected static parsePreprocess(context: PreprocessorContext, code: string, defineValue: {
+        [name: string]: any;
+    }): string;
+    protected static parseAutoBindingForAllGroup(code: string): string;
+    protected static parseAutoBindingForGroupX(code: string, nGroup: number): string;
+    protected static parseAutoLocation(code: string): string;
+    protected static parseAutoLocationBlock(code: string): string;
+    protected static parsePreprocessCommand(context: PreprocessorContext, code: string, defineValue: {
+        [name: string]: any;
+    }): string;
+    protected static parseCondition(condition: string, defineValue: {
+        [name: string]: any;
+    }): boolean;
+    static filterComment(code: string): string;
+    protected static extract(str: string, leftStr: string, rightStr: string): string;
+}
+declare class PreprocessorContext {
+    includeMap: Map<string, boolean>;
+    constructor();
+}
+export {};