@rings-webgpu/core 1.0.2 → 1.0.3

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

@@ -1,174 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,219 +0,0 @@
-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

@@ -1,206 +0,0 @@
-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;
-}