@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/gfx/graphics/webGpu/descriptor/WebGPUDescriptorCreator.js

@@ -0,0 +1,174 @@
+import { RTResourceConfig } from "../../../renderJob/config/RTResourceConfig";
+import { webGPUContext } from "../Context3D";
+import { RendererPassState } from "../../../renderJob/passRenderer/state/RendererPassState";
+import { GBufferFrame } from "../../../renderJob/frame/GBufferFrame";
+export class WebGPUDescriptorCreator {
+    static { this.rendererPassState = new Map(); }
+    static createRendererPassState(rtFrame, loadOp = null) {
+        let rps = WebGPUDescriptorCreator.rendererPassState.get(rtFrame);
+        if (!rps) {
+            rps = new RendererPassState();
+            rps.label = rtFrame.label;
+            rps.customSize = rtFrame.customSize;
+            rps.rtFrame = rtFrame;
+            rps.zPreTexture = rtFrame.zPreTexture;
+            rps.depthTexture = rtFrame.depthTexture;
+            rps.depthViewIndex = rtFrame.depthViewIndex;
+            rps.isOutTarget = rtFrame.isOutTarget;
+            rps.depthCleanValue = rtFrame.depthCleanValue;
+            rps.depthLoadOp = rtFrame.depthLoadOp;
+            WebGPUDescriptorCreator.rendererPassState.set(rtFrame, rps);
+        }
+        if (rtFrame && rtFrame.renderTargets.length > 0) {
+            rps.renderTargets = rtFrame.renderTargets;
+            rps.rtTextureDescriptors = rtFrame.rtDescriptors;
+            rps.renderPassDescriptor =
+                WebGPUDescriptorCreator.getRenderPassDescriptor(rps);
+            if (rps.renderPassDescriptor.depthStencilAttachment) {
+                rps.renderPassDescriptor.depthStencilAttachment.depthLoadOp =
+                    rtFrame.depthLoadOp;
+            }
+            if (loadOp == "load" &&
+                rtFrame?.renderTargets[0] &&
+                rtFrame.renderTargets[0].name.startsWith(GBufferFrame.gui_GBuffer)) {
+                rps.renderPassDescriptor.colorAttachments[0].loadOp = "load";
+            }
+            rps.depthLoadOp = rtFrame.depthLoadOp;
+            rps.renderBundleEncoderDescriptor =
+                WebGPUDescriptorCreator.getRenderBundleDescriptor(rps);
+            rps.renderTargetTextures = [];
+            for (let i = 0; i < rtFrame.renderTargets.length; i++) {
+                const element = rtFrame.renderTargets[i];
+                rps.renderTargetTextures[i] = {
+                    format: element.format,
+                };
+                if (element.name.indexOf(RTResourceConfig.colorBufferTex_NAME) != -1) {
+                    rps.outColor = i;
+                }
+            }
+        }
+        else {
+            rps.renderPassDescriptor =
+                WebGPUDescriptorCreator.getRenderPassDescriptor(rps, loadOp);
+            rps.renderBundleEncoderDescriptor =
+                WebGPUDescriptorCreator.getRenderBundleDescriptor(rps);
+            rps.renderTargetTextures = [
+                {
+                    format: webGPUContext.presentationFormat,
+                },
+            ];
+            rps.outColor = 0;
+        }
+        return rps;
+    }
+    static getRenderPassDescriptor(renderPassState, loadOp = null) {
+        if (renderPassState.renderPassDescriptor)
+            return renderPassState.renderPassDescriptor;
+        let device = webGPUContext.device;
+        let presentationSize = webGPUContext.presentationSize;
+        let attachMentTexture = [];
+        let size = [];
+        if (renderPassState.renderTargets &&
+            renderPassState.renderTargets.length > 0) {
+            size = [
+                renderPassState.renderTargets[0].width,
+                renderPassState.renderTargets[0].height,
+            ];
+            for (let i = 0; i < renderPassState.renderTargets.length; i++) {
+                const texture = renderPassState.renderTargets[i];
+                const rtDesc = renderPassState.rtTextureDescriptors[i];
+                attachMentTexture.push({
+                    view: texture.getGPUView(),
+                    resolveTarget: undefined,
+                    loadOp: rtDesc.loadOp, // webGPUContext.canvasConfig && webGPUContext.canvasConfig.alpha ? `load` : `clear`,
+                    clearValue: rtDesc.clearValue,
+                    storeOp: rtDesc.storeOp,
+                });
+            }
+        }
+        else {
+            if (!renderPassState.customSize) {
+                let clearValue = webGPUContext.canvasConfig && webGPUContext.canvasConfig.alpha
+                    ? [1.0, 1.0, 1.0, 0.0]
+                    : [0.0, 0.0, 0.0, 1.0];
+                size = presentationSize;
+                if (renderPassState.isOutTarget == true) {
+                    attachMentTexture.push({
+                        view: undefined,
+                        resolveTarget: undefined,
+                        loadOp: (webGPUContext.canvasConfig &&
+                            webGPUContext.canvasConfig.alpha) ||
+                            loadOp != null
+                            ? `load`
+                            : `clear`,
+                        clearValue: clearValue,
+                        storeOp: "store",
+                    });
+                }
+            }
+        }
+        let renderPassDescriptor = null;
+        if (renderPassState.depthTexture || renderPassState.zPreTexture) {
+            if (renderPassState.zPreTexture) {
+                renderPassState.depthTexture = renderPassState.zPreTexture;
+            }
+            renderPassDescriptor = {
+                label: `${renderPassState.label} renderPassDescriptor zPreTexture${renderPassState.zPreTexture ? `load` : `clear`}`,
+                colorAttachments: attachMentTexture,
+                depthStencilAttachment: {
+                    view: renderPassState.depthTexture.getGPUView(),
+                    depthLoadOp: renderPassState.zPreTexture
+                        ? `load`
+                        : renderPassState.depthLoadOp,
+                    depthClearValue: renderPassState.zPreTexture
+                        ? 1
+                        : renderPassState.depthCleanValue,
+                    depthStoreOp: "store",
+                },
+            };
+        }
+        else {
+            renderPassDescriptor = {
+                colorAttachments: attachMentTexture,
+                label: "renderPassDescriptor not writeDepth",
+            };
+        }
+        renderPassState.renderPassDescriptor = renderPassDescriptor;
+        return renderPassDescriptor;
+    }
+    static getRenderBundleDescriptor(renderPassState) {
+        if (renderPassState.renderBundleEncoderDescriptor)
+            return renderPassState.renderBundleEncoderDescriptor;
+        let presentationSize = webGPUContext.presentationSize;
+        let attachMentTexture = [];
+        let size = [];
+        if (renderPassState.renderTargets &&
+            renderPassState.renderTargets.length > 0) {
+            size = [
+                renderPassState.renderTargets[0].width,
+                renderPassState.renderTargets[0].height,
+            ];
+            for (let i = 0; i < renderPassState.renderTargets.length; i++) {
+                const renderTarget = renderPassState.renderTargets[i];
+                attachMentTexture.push(renderTarget.format);
+            }
+        }
+        else {
+            size = presentationSize;
+        }
+        let renderPassDescriptor = null;
+        if (renderPassState.depthTexture) {
+            renderPassDescriptor = {
+                colorFormats: attachMentTexture,
+                depthStencilFormat: renderPassState.depthTexture.format,
+            };
+        }
+        else {
+            renderPassDescriptor = {
+                colorFormats: attachMentTexture,
+            };
+        }
+        renderPassState.renderBundleEncoderDescriptor = renderPassDescriptor;
+        return renderPassState.renderBundleEncoderDescriptor;
+    }
+}

package/dist/src/gfx/graphics/webGpu/shader/ComputeShader.d.ts

@@ -0,0 +1,28 @@
+import { Texture } from "../core/texture/Texture";
+import { ShaderPassBase } from "./ShaderPassBase";
+import { ShaderReflectionVarInfo } from "./value/ShaderReflectionInfo";
+export declare class ComputeShader extends ShaderPassBase {
+    entryPoint: string;
+    workerSizeX: number;
+    workerSizeY: number;
+    workerSizeZ: number;
+    protected _computePipeline: GPUComputePipeline;
+    protected _csShaderModule: GPUShaderModule;
+    protected _destCS: string;
+    protected _sourceCS: string;
+    private _storageTextureDic;
+    private _sampleTextureDic;
+    private _groupsShaderReflectionVarInfos;
+    private _groupCache;
+    constructor(computeShader: string);
+    setStorageTexture(name: string, texture: Texture): void;
+    setSamplerTexture(name: string, texture: Texture): void;
+    compute(computePass: GPUComputePassEncoder): void;
+    private createBufferBindGroup;
+    protected noticeBufferChange(name: string): void;
+    protected genGroups(groupIndex: number, infos: ShaderReflectionVarInfo[][], force?: boolean): void;
+    protected genComputePipeline(): void;
+    protected preCompileShader(shader: string): void;
+    protected compileShader(): GPUShaderModule;
+    private genReflection;
+}

package/dist/src/gfx/graphics/webGpu/shader/ComputeShader.js

@@ -0,0 +1,219 @@
+import { webGPUContext } from "../Context3D";
+import { ShaderPassBase } from "./ShaderPassBase";
+import { ShaderReflection, } from "./value/ShaderReflectionInfo";
+import { Preprocessor } from "./util/Preprocessor";
+import { CResizeEvent, Reference } from "../../../..";
+export class ComputeShader extends ShaderPassBase {
+    constructor(computeShader) {
+        super();
+        this.entryPoint = `CsMain`;
+        this.workerSizeX = 1;
+        this.workerSizeY = 0;
+        this.workerSizeZ = 0;
+        this._groupCache = {};
+        this._sourceCS = computeShader;
+        ShaderReflection.getShaderReflection2(computeShader, this);
+        this._storageTextureDic = new Map();
+        this._sampleTextureDic = new Map();
+    }
+    setStorageTexture(name, texture) {
+        if (!this._storageTextureDic.has(name)) {
+            this._storageTextureDic.set(name, texture);
+        }
+    }
+    setSamplerTexture(name, texture) {
+        this._sampleTextureDic.set(name, texture);
+    }
+    compute(computePass) {
+        if (!this._computePipeline) {
+            this.genComputePipeline();
+        }
+        computePass.setPipeline(this._computePipeline);
+        for (let i = 0; i < this.bindGroups.length; ++i) {
+            computePass.setBindGroup(i, this.bindGroups[i]);
+        }
+        if (this.workerSizeX && this.workerSizeY && this.workerSizeZ) {
+            computePass.dispatchWorkgroups(this.workerSizeX, this.workerSizeY, this.workerSizeZ);
+        }
+        else if (this.workerSizeX && this.workerSizeY) {
+            computePass.dispatchWorkgroups(this.workerSizeX, this.workerSizeY);
+        }
+        else {
+            computePass.dispatchWorkgroups(this.workerSizeX);
+        }
+    }
+    createBufferBindGroup(groupIndex, varName, binding, entries) {
+        let buffer = this._bufferDic.get(varName);
+        if (buffer) {
+            let entry = {
+                binding: binding,
+                resource: {
+                    buffer: buffer.buffer,
+                    offset: 0, //buffer.memory.shareFloat32Array.byteOffset,
+                    size: buffer.memory.shareDataBuffer.byteLength,
+                },
+            };
+            entries.push(entry);
+        }
+        else {
+            console.error(`ComputeShader(${this.instanceID})`, `buffer ${varName} is missing!`);
+        }
+    }
+    noticeBufferChange(name) {
+        let bindGroupCache = this._groupCache[name];
+        if (bindGroupCache) {
+            this.genGroups(bindGroupCache.groupIndex, bindGroupCache.infos, true);
+        }
+    }
+    genGroups(groupIndex, infos, force = false) {
+        if (!this.bindGroups[groupIndex] || force) {
+            const shaderRefs = infos[groupIndex];
+            let entries = [];
+            for (let j = 0; j < shaderRefs.length; ++j) {
+                const refs = shaderRefs[j];
+                if (!refs)
+                    continue;
+                switch (refs.varType) {
+                    case `uniform`:
+                    case `storage-read`:
+                    case `storage-read_write`:
+                        {
+                            this.createBufferBindGroup(groupIndex, refs.varName, refs.binding, entries);
+                            this._groupCache[refs.varName] = {
+                                groupIndex: groupIndex,
+                                infos: infos,
+                            };
+                        }
+                        break;
+                    case `var`:
+                        {
+                            if (refs.dataType == `sampler`) {
+                                let textureName = refs.varName.replace(`Sampler`, ``);
+                                let texture = this._sampleTextureDic.get(textureName);
+                                if (texture) {
+                                    let entry = {
+                                        binding: refs.binding,
+                                        resource: texture.gpuSampler,
+                                    };
+                                    entries.push(entry);
+                                }
+                                else {
+                                    console.error(`ComputeShader(${this.instanceID})`, `texture ${refs.varName} is missing! `);
+                                }
+                            }
+                            else if (refs.dataType == `sampler_comparison`) {
+                                let textureName = refs.varName.replace(`Sampler`, ``);
+                                let texture = this._sampleTextureDic.get(textureName);
+                                if (texture) {
+                                    let entry = {
+                                        binding: refs.binding,
+                                        resource: texture.gpuSampler_comparison,
+                                    };
+                                    entries.push(entry);
+                                }
+                                else {
+                                    console.error(`ComputeShader(${this.instanceID})`, `texture ${refs.varName} is missing! `);
+                                }
+                            }
+                            else if (refs.dataType.indexOf("texture_storage") != -1) {
+                                let texture = this._storageTextureDic.get(refs.varName);
+                                if (texture) {
+                                    let entry = {
+                                        binding: refs.binding,
+                                        resource: texture.getGPUView(),
+                                    };
+                                    entries.push(entry);
+                                    Reference.getInstance().attached(texture, this);
+                                }
+                                else {
+                                    console.error(`ComputeShader(${this.instanceID})`, `texture ${refs.varName} is missing! `);
+                                }
+                            }
+                            else if (refs.dataType.indexOf("texture") != -1) {
+                                let texture = this._sampleTextureDic.get(refs.varName);
+                                if (texture) {
+                                    let entry = {
+                                        binding: refs.binding,
+                                        resource: texture.getGPUView(),
+                                    };
+                                    entries.push(entry);
+                                    Reference.getInstance().attached(texture, this);
+                                }
+                                else {
+                                    console.error(`ComputeShader(${this.instanceID})`, `texture ${refs.varName} is missing! `);
+                                }
+                            }
+                        }
+                        break;
+                    default:
+                        console.error(`unprocessed type:`, refs.varType);
+                        break;
+                }
+            }
+            let gpubindGroup = webGPUContext.device.createBindGroup({
+                layout: this._computePipeline.getBindGroupLayout(groupIndex),
+                entries: entries,
+            });
+            this.bindGroups[groupIndex] = gpubindGroup;
+        }
+    }
+    genComputePipeline() {
+        this.preCompileShader(this._sourceCS);
+        this.genReflection();
+        this._computePipeline = webGPUContext.device.createComputePipeline({
+            layout: `auto`,
+            compute: {
+                module: this.compileShader(),
+                entryPoint: this.entryPoint,
+            },
+        });
+        this._groupsShaderReflectionVarInfos = [];
+        let shaderReflection = this.shaderReflection;
+        this.bindGroups = [];
+        for (let i = 0; i < shaderReflection.groups.length; ++i) {
+            let srvs = shaderReflection.groups[i];
+            this._groupsShaderReflectionVarInfos[i] = srvs;
+            this.genGroups(i, this._groupsShaderReflectionVarInfos);
+        }
+        webGPUContext.addEventListener(CResizeEvent.RESIZE, (e) => {
+            for (let i = 0; i < shaderReflection.groups.length; ++i) {
+                let srvs = shaderReflection.groups[i];
+                this._groupsShaderReflectionVarInfos[i] = srvs;
+                this.genGroups(i, this._groupsShaderReflectionVarInfos, true);
+            }
+        }, this);
+    }
+    preCompileShader(shader) {
+        for (const key in this.constValues) {
+            if (Object.prototype.hasOwnProperty.call(this.constValues, key)) {
+                const value = this.constValues[key];
+                shader = shader.replaceAll(`&${key}`, value.toString());
+            }
+        }
+        this._destCS = Preprocessor.parseComputeShader(shader, this.defineValue);
+    }
+    compileShader() {
+        let shaderModule = webGPUContext.device.createShaderModule({
+            label: `ComputeShader(${this.instanceID})`,
+            code: this._destCS,
+        });
+        shaderModule.getCompilationInfo().then((e) => {
+            if (e.messages.length > 0) {
+                console.warn("[shader error]", e, this._destCS);
+            }
+        });
+        this._csShaderModule = shaderModule;
+        return shaderModule;
+    }
+    genReflection() {
+        this.shaderVariant += ShaderReflection.genComputeShaderVariant(this);
+        let reflection = ShaderReflection.poolGetReflection(this.shaderVariant);
+        if (!reflection) {
+            ShaderReflection.getShaderReflection2(this._destCS, this);
+            ShaderReflection.combineShaderReflectionVarInfo(this.shaderReflection, this.shaderReflection.cs_variables);
+        }
+        else {
+            this.shaderReflection = reflection;
+        }
+    }
+}

package/dist/src/gfx/graphics/webGpu/shader/RenderShaderPass.d.ts

@@ -0,0 +1,206 @@
+import { Color } from "../../../../math/Color";
+import { BlendMode } from "../../../../materials/BlendMode";
+import { GeometryBase } from "../../../../core/geometry/GeometryBase";
+import { GPUBufferBase } from "../core/buffer/GPUBufferBase";
+import { Texture } from "../core/texture/Texture";
+import { ShaderPassBase } from "./ShaderPassBase";
+import { ShaderStage } from "./ShaderStage";
+import { ShaderReflectionVarInfo } from "./value/ShaderReflectionInfo";
+import { ShaderState } from "./value/ShaderState";
+import { RendererPassState } from "../../../renderJob/passRenderer/state/RendererPassState";
+import { UniformValue } from "./value/UniformValue";
+import { PassType } from "../../../renderJob/passRenderer/state/PassType";
+import { Vector4 } from "../../../../math/Vector4";
+export declare class RenderShaderPass extends ShaderPassBase {
+    passType: PassType;
+    useRz: boolean;
+    /**
+     * Vertex shader name
+     */
+    vsName: string;
+    /**
+     * Fragment shader name
+     */
+    fsName: string;
+    /**
+     * State of the shader
+     */
+    shaderState: ShaderState;
+    /**
+     * The collection of textures used in shading
+     */
+    textures: {
+        [name: string]: Texture;
+    };
+    /**
+     * Render pipeline
+     */
+    pipeline: GPURenderPipeline;
+    /**
+     * BindGroup layout
+     */
+    bindGroupLayouts: GPUBindGroupLayout[];
+    envMap: Texture;
+    prefilterMap: Texture;
+    reflectionMap: Texture;
+    protected _sourceVS: string;
+    protected _sourceFS: string;
+    protected _destVS: string;
+    protected _destFS: string;
+    protected _vsShaderModule: GPUShaderModule;
+    protected _fsShaderModule: GPUShaderModule;
+    protected _textureGroup: number;
+    protected _textureChange: boolean;
+    protected _groupsShaderReflectionVarInfos: ShaderReflectionVarInfo[][];
+    outBufferMask: Vector4;
+    constructor(vs: string, fs: string);
+    /**
+     * Blend mode
+     */
+    get renderOrder(): number;
+    set renderOrder(value: number);
+    /**
+        * Cull mode
+        */
+    get doubleSide(): boolean;
+    set doubleSide(value: boolean);
+    /**
+     * depthWriteEnabled mode
+     */
+    get depthWriteEnabled(): boolean;
+    set depthWriteEnabled(value: boolean);
+    /**
+     * get render face cull mode
+     */
+    get cullMode(): GPUCullMode;
+    /**
+     * set render face cull mode
+     */
+    set cullMode(value: GPUCullMode);
+    /**
+     * get front face mode
+     * @GPUFrontFace
+     */
+    get frontFace(): GPUFrontFace;
+    /**
+     * set front face mode
+     * @GPUFrontFace value
+     */
+    set frontFace(value: GPUFrontFace);
+    /**
+     * Depth bias
+     */
+    get depthBias(): number;
+    set depthBias(value: number);
+    /**
+     * Primitive topology
+     */
+    get topology(): GPUPrimitiveTopology;
+    set topology(value: GPUPrimitiveTopology);
+    /**
+     * Blend mode
+     */
+    get blendMode(): BlendMode;
+    set blendMode(value: BlendMode);
+    /**
+     * Depth compare function
+     */
+    get depthCompare(): GPUCompareFunction;
+    set depthCompare(value: GPUCompareFunction);
+    /**
+     * Sets the entry point names for the RenderShader vertex phase and fragment phase
+     * @param vsEntryPoint
+     * @param fsEntryPoint
+     */
+    setShaderEntry(vsEntryPoint?: string, fsEntryPoint?: string): void;
+    /**
+     *
+     * @param String name
+     * @param UniformValue value
+     */
+    setUniform(name: string, value: UniformValue): void;
+    /**
+     * Set the texture used in the Render Shader code
+     * @param name Name in the shader code
+     * @param texture Texture object
+     */
+    setTexture(name: string, texture: Texture): void;
+    get baseColor(): Color;
+    set baseColor(value: Color);
+    /**
+     * Get the texture used in the Render Shader code
+     * @param name Name in the shader code
+     * @returns Texture object
+     */
+    getTexture(name: string): Texture;
+    /**
+     * Create a rendering pipeline
+     * @param geometry
+     * @param renderPassState
+     */
+    genRenderPipeline(geometry: GeometryBase, renderPassState: RendererPassState): void;
+    /**
+     * Recompile the shader and create the rendering pipeline
+     * @param geometry
+     * @param rendererPassState
+     */
+    reBuild(geometry: GeometryBase, rendererPassState: RendererPassState): void;
+    /**
+     * Apply render shader state value
+     * @param geometry
+     * @param materialPass
+     * @param rendererPassState
+     * @param noticeFun
+     */
+    apply(geometry: GeometryBase, rendererPassState: RendererPassState, noticeFun?: Function): void;
+    /**
+     * Precompile the shader code
+     * @param geometry
+     */
+    preCompile(geometry: GeometryBase): void;
+    /**
+     * Apply defines syntax values
+     * @param shader
+     * @param renderPassState
+     * @returns
+     */
+    applyPostDefine(shader: string, renderPassState: RendererPassState): string;
+    /**
+     * Set GPUBindGroup to the specified index slot
+     * @param groupIndex
+     * @param group
+     */
+    setBindGroup(groupIndex: number, group: GPUBindGroup): void;
+    protected checkBuffer(bufferName: string, buffer: GPUBufferBase): void;
+    protected preCompileShader(stage: ShaderStage, code: string, format?: string): void;
+    protected compileShader(stage: ShaderStage, code: string, renderPassState: RendererPassState): void;
+    protected getGroupLayout(index: number, infos: ShaderReflectionVarInfo[]): GPUBindGroupLayoutEntry[];
+    private _cacheEntries;
+    protected genGroups(groupIndex: number, infos: ShaderReflectionVarInfo[][], force?: boolean): void;
+    private createPipeline;
+    private createGroupLayouts;
+    private preDefine;
+    private genReflection;
+    /**
+     * Destroy and release render shader related resources
+     */
+    destroy(force?: boolean): void;
+    /**
+     * Destroy a RenderShader object
+     * @param instanceID instance ID of the RenderShader
+     */
+    static destroyShader(instanceID: string): void;
+    /**
+     * Get the RenderShader object by specifying the RenderShader instance ID
+     * @param instanceID instance ID of the RenderShader
+     * @returns RenderShader object
+     */
+    static getShader(instanceID: string): RenderShaderPass;
+    /**
+     * Create a RenderShader with vertex shaders and fragment shaders
+     * @param vs Vertex shader name
+     * @param fs Fragment shader name
+     * @returns Returns the instance ID of the RenderShader
+     */
+    static createShader(vs: string, fs: string): string;
+}