@rings-webgpu/core 1.0.2 → 1.0.3

package/dist/src/gfx/renderJob/collect/RenderShaderCollect.d.ts

@@ -1,9 +0,0 @@
-import { RenderNode } from "../../../components/renderer/RenderNode";
-import { View3D } from "../../../core/View3D";
-export type RenderShaderList = Map<string, Map<string, RenderNode>>;
-export declare class RenderShaderCollect {
-    renderShaderUpdateList: Map<View3D, RenderShaderList>;
-    renderNodeList: Map<View3D, Map<string, RenderNode>>;
-    collect_add(node: RenderNode): void;
-    collect_remove(node: RenderNode): void;
-}

package/dist/src/gfx/renderJob/collect/RenderShaderCollect.js

@@ -1,51 +0,0 @@
-export class RenderShaderCollect {
-    constructor() {
-        this.renderShaderUpdateList = new Map();
-        this.renderNodeList = new Map();
-    }
-    collect_add(node) {
-        let view = node.transform.view3D;
-        if (view && node.materials) {
-            node.materials.forEach((mat) => {
-                let rDic = this.renderShaderUpdateList.get(view);
-                if (!rDic) {
-                    rDic = new Map();
-                    this.renderShaderUpdateList.set(view, rDic);
-                }
-                let renderGlobalMap = this.renderNodeList.get(view);
-                if (!renderGlobalMap) {
-                    renderGlobalMap = new Map();
-                    this.renderNodeList.set(view, renderGlobalMap);
-                }
-                renderGlobalMap.set(node.instanceID, node);
-                let colorPassList = mat.getAllPass();
-                for (let i = 0; i < colorPassList.length; i++) {
-                    const pass = colorPassList[i];
-                    let key = `${node.geometry.instanceID + pass.instanceID}`;
-                    let nodeMap = rDic.get(key);
-                    if (!nodeMap) {
-                        nodeMap = new Map();
-                        rDic.set(key, nodeMap);
-                    }
-                    nodeMap.set(node.instanceID, node);
-                }
-            });
-        }
-    }
-    collect_remove(node) {
-        let view = node.transform.view3D;
-        if (view && node.materials) {
-            let rDic = this.renderShaderUpdateList.get(view);
-            if (rDic) {
-                node.materials.forEach((mat) => {
-                    let colorPassList = mat.getAllPass();
-                    for (let i = 0; i < colorPassList.length; i++) {
-                        const pass = colorPassList[i];
-                        let key = `${node.geometry.instanceID + pass.instanceID}`;
-                        rDic.delete(key);
-                    }
-                });
-            }
-        }
-    }
-}

package/dist/src/gfx/renderJob/collect/ShadowLightsCollect.d.ts

@@ -1,20 +0,0 @@
-import { ILight } from "../../../components/lights/ILight";
-import { LightType } from "../../../components/lights/LightData";
-import { Scene3D } from "../../../core/Scene3D";
-import { View3D } from "../../../core/View3D";
-export declare class ShadowLightsCollect {
-    static maxNumDirectionShadow: number;
-    static maxNumPointShadow: number;
-    static directionLightList: Map<Scene3D, ILight[]>;
-    static pointLightList: Map<Scene3D, ILight[]>;
-    static shadowLights: Map<Scene3D, Float32Array>;
-    static init(): void;
-    static createBuffer(view: View3D): void;
-    static getShadowLightList(light: ILight): ILight[];
-    static getShadowLightWhichScene(scene: Scene3D, type: LightType): ILight[];
-    static getDirectShadowLightWhichScene(scene: Scene3D): ILight[];
-    static getPointShadowLightWhichScene(scene: Scene3D): ILight[];
-    static addShadowLight(light: ILight): ILight[];
-    static removeShadowLight(light: ILight): ILight[];
-    static update(view: View3D): void;
-}

package/dist/src/gfx/renderJob/collect/ShadowLightsCollect.js

@@ -1,182 +0,0 @@
-import { LightType } from "../../../components/lights/LightData";
-import { CameraUtil } from "../../../util/CameraUtil";
-import { GlobalBindGroup } from "../../graphics/webGpu/core/bindGroups/GlobalBindGroup";
-export class ShadowLightsCollect {
-    static { this.maxNumDirectionShadow = 8; }
-    static { this.maxNumPointShadow = 8; }
-    static init() {
-        this.directionLightList = new Map();
-        this.pointLightList = new Map();
-        this.shadowLights = new Map();
-    }
-    static createBuffer(view) {
-        if (!this.shadowLights.has(view.scene)) {
-            let list = new Float32Array(16);
-            this.shadowLights.set(view.scene, list);
-        }
-    }
-    static getShadowLightList(light) {
-        if (!light.transform.view3D)
-            return null;
-        if (light.lightData.lightType == LightType.DirectionLight) {
-            let list = this.directionLightList.get(light.transform.view3D.scene);
-            if (!list) {
-                list = [];
-                this.directionLightList.set(light.transform.view3D.scene, list);
-            }
-            return list;
-        }
-        else if (light.lightData.lightType == LightType.PointLight) {
-            let list = this.pointLightList.get(light.transform.view3D.scene);
-            if (!list) {
-                list = [];
-                this.pointLightList.set(light.transform.view3D.scene, list);
-            }
-            return list;
-        }
-        else if (light.lightData.lightType == LightType.SpotLight) {
-            let list = this.pointLightList.get(light.transform.view3D.scene);
-            if (!list) {
-                list = [];
-                this.pointLightList.set(light.transform.view3D.scene, list);
-            }
-            return list;
-        }
-    }
-    static getShadowLightWhichScene(scene, type) {
-        if (type == LightType.DirectionLight) {
-            let list = this.directionLightList.get(scene);
-            if (!list) {
-                list = [];
-                this.directionLightList.set(scene, list);
-            }
-            return list;
-        }
-        else if (type == LightType.PointLight) {
-            let list = this.pointLightList.get(scene);
-            if (!list) {
-                list = [];
-                this.pointLightList.set(scene, list);
-            }
-            return list;
-        }
-    }
-    static getDirectShadowLightWhichScene(scene) {
-        let list = this.directionLightList.get(scene);
-        if (!list) {
-            list = [];
-            this.directionLightList.set(scene, list);
-        }
-        return list;
-    }
-    static getPointShadowLightWhichScene(scene) {
-        let list = this.pointLightList.get(scene);
-        if (!list) {
-            list = [];
-            this.pointLightList.set(scene, list);
-        }
-        return list;
-    }
-    static addShadowLight(light) {
-        if (!light.transform.view3D)
-            return null;
-        let scene = light.transform.view3D.scene;
-        if (light.lightData.lightType == LightType.DirectionLight) {
-            let list = this.directionLightList.get(scene);
-            if (!list) {
-                list = [];
-                this.directionLightList.set(scene, list);
-            }
-            if (!light.shadowCamera) {
-                light.shadowCamera = CameraUtil.createCamera3DObject(null, "shadowCamera");
-                light.shadowCamera.isShadowCamera = true;
-                let shadowBound = -1000;
-                light.shadowCamera.orthoOffCenter(shadowBound, -shadowBound, shadowBound, -shadowBound, 1, 10000);
-            }
-            if (list.indexOf(light) == -1) {
-                list.push(light);
-            }
-            return list;
-        }
-        else if (light.lightData.lightType == LightType.PointLight ||
-            light.lightData.lightType == LightType.SpotLight) {
-            let list = this.pointLightList.get(scene);
-            if (list && list.length >= 8) {
-                return list;
-            }
-            if (!list) {
-                list = [];
-                this.pointLightList.set(scene, list);
-            }
-            if (list.indexOf(light) == -1) {
-                list.push(light);
-            }
-            return list;
-        }
-    }
-    static removeShadowLight(light) {
-        light.lightData.castShadowIndex = -1;
-        if (!light.transform.view3D)
-            return null;
-        if (light.lightData.lightType == LightType.DirectionLight) {
-            let list = this.directionLightList.get(light.transform.view3D.scene);
-            if (list) {
-                let index = list.indexOf(light);
-                if (index != -1) {
-                    list.splice(index, 1);
-                }
-            }
-            light.lightData.castShadowIndex = -1;
-            return list;
-        }
-        else if (light.lightData.lightType == LightType.PointLight ||
-            light.lightData.lightType == LightType.SpotLight) {
-            let list = this.pointLightList.get(light.transform.view3D.scene);
-            if (list) {
-                let index = list.indexOf(light);
-                if (index != -1) {
-                    list.splice(index, 1);
-                }
-            }
-            light.lightData.castShadowIndex = -1;
-            return list;
-        }
-    }
-    static update(view) {
-        let shadowLights = this.shadowLights.get(view.scene);
-        let directionLightList = ShadowLightsCollect.directionLightList.get(view.scene);
-        let pointLightList = ShadowLightsCollect.pointLightList.get(view.scene);
-        let nDirShadowStart = 0;
-        let nDirShadowEnd = 0;
-        let nPointShadowStart = 0;
-        let nPointShadowEnd = 0;
-        shadowLights.fill(0);
-        if (directionLightList) {
-            let j = 0;
-            for (let i = 0; i < directionLightList.length; i++) {
-                const light = directionLightList[i];
-                shadowLights[i] = light.lightData.index;
-                light.lightData.castShadowIndex = j++;
-            }
-            nDirShadowEnd = directionLightList.length;
-        }
-        if (pointLightList) {
-            nPointShadowStart = nDirShadowEnd;
-            let j = 0;
-            for (let i = nPointShadowStart; i < pointLightList.length; i++) {
-                const light = pointLightList[i];
-                shadowLights[i] = light.lightData.index;
-                light.lightData.castShadowIndex = j++;
-            }
-            nPointShadowEnd = nPointShadowStart + pointLightList.length;
-        }
-        let cameraGroup = GlobalBindGroup.getAllCameraGroup();
-        cameraGroup.forEach((group) => {
-            group.dirShadowStart = nDirShadowStart;
-            group.dirShadowEnd = nDirShadowEnd;
-            group.pointShadowStart = nPointShadowStart;
-            group.pointShadowEnd = nPointShadowEnd;
-            group.shadowLights.set(new Float32Array(shadowLights));
-        });
-    }
-}

package/dist/src/gfx/renderJob/config/RTResourceConfig.d.ts

@@ -1,10 +0,0 @@
-export declare class RTResourceConfig {
-    static compressGBufferTex_NAME: string;
-    static colorBufferTex_NAME: string;
-    static positionBufferTex_NAME: string;
-    static normalBufferTex_NAME: string;
-    static materialBufferTex_NAME: string;
-    static zBufferTexture_NAME: string;
-    static zPreDepthTexture_NAME: string;
-    static outTex_NAME: string;
-}

package/dist/src/gfx/renderJob/config/RTResourceConfig.js

@@ -1,10 +0,0 @@
-export class RTResourceConfig {
-    static { this.compressGBufferTex_NAME = "compressGBufferTex_NAME"; }
-    static { this.colorBufferTex_NAME = "colorBufferTex"; }
-    static { this.positionBufferTex_NAME = "positionBufferTex"; }
-    static { this.normalBufferTex_NAME = "normalBufferTex"; }
-    static { this.materialBufferTex_NAME = "materialBufferTex"; }
-    static { this.zBufferTexture_NAME = "zBufferTexture"; }
-    static { this.zPreDepthTexture_NAME = "zPreDepthTexture"; }
-    static { this.outTex_NAME = "outTex"; }
-}

package/dist/src/gfx/renderJob/config/RenderLayer.d.ts

@@ -1,11 +0,0 @@
-export declare enum RenderLayer {
-    None = 2,
-    StaticBatch = 4,
-    DynamicBatch = 8,
-    Hiden = 16
-}
-export declare class RenderLayerUtil {
-    static addMask(src: RenderLayer, tag: RenderLayer): RenderLayer;
-    static removeMask(src: RenderLayer, tag: RenderLayer): RenderLayer;
-    static hasMask(m1: RenderLayer, m2: RenderLayer): boolean;
-}

package/dist/src/gfx/renderJob/config/RenderLayer.js

@@ -1,20 +0,0 @@
-export var RenderLayer;
-(function (RenderLayer) {
-    RenderLayer[RenderLayer["None"] = 2] = "None";
-    RenderLayer[RenderLayer["StaticBatch"] = 4] = "StaticBatch";
-    RenderLayer[RenderLayer["DynamicBatch"] = 8] = "DynamicBatch";
-    RenderLayer[RenderLayer["Hiden"] = 16] = "Hiden";
-})(RenderLayer || (RenderLayer = {}));
-export class RenderLayerUtil {
-    static addMask(src, tag) {
-        let value = src | tag;
-        return value;
-    }
-    static removeMask(src, tag) {
-        let value = src & ~tag;
-        return value;
-    }
-    static hasMask(m1, m2) {
-        return (m1 & m2) != 0;
-    }
-}

package/dist/src/gfx/renderJob/frame/GBufferFrame.d.ts

@@ -1,19 +0,0 @@
-import { RenderTexture } from "../../../textures/RenderTexture";
-import { RTFrame } from "./RTFrame";
-export declare class GBufferFrame extends RTFrame {
-    static colorPass_GBuffer: string;
-    static reflections_GBuffer: string;
-    static gui_GBuffer: string;
-    static gBufferMap: Map<string, GBufferFrame>;
-    private _colorBufferTex;
-    private _compressGBufferTex;
-    constructor();
-    createGBuffer(key: string, rtWidth: number, rtHeight: number, autoResize?: boolean, outColor?: boolean, depthTexture?: RenderTexture): void;
-    getPositionMap(): RenderTexture;
-    getNormalMap(): RenderTexture;
-    getColorTexture(): RenderTexture;
-    getCompressGBufferTexture(): RenderTexture;
-    static getGBufferFrame(key: string, fixedWidth?: number, fixedHeight?: number, outColor?: boolean, depthTexture?: RenderTexture): GBufferFrame;
-    static getGUIBufferFrame(): GBufferFrame;
-    clone(): GBufferFrame;
-}

package/dist/src/gfx/renderJob/frame/GBufferFrame.js

@@ -1,74 +0,0 @@
-import { RenderTexture } from "../../../textures/RenderTexture";
-import { webGPUContext } from "../../graphics/webGpu/Context3D";
-import { GPUTextureFormat } from "../../graphics/webGpu/WebGPUConst";
-import { RTDescriptor } from "../../graphics/webGpu/descriptor/RTDescriptor";
-import { RTResourceConfig } from "../config/RTResourceConfig";
-import { RTFrame } from "./RTFrame";
-import { RTResourceMap } from "./RTResourceMap";
-export class GBufferFrame extends RTFrame {
-    static { this.colorPass_GBuffer = "ColorPassGBuffer"; }
-    static { this.reflections_GBuffer = "reflections_GBuffer"; }
-    static { this.gui_GBuffer = "gui_GBuffer"; }
-    static { this.gBufferMap = new Map(); }
-    constructor() {
-        super([], []);
-    }
-    createGBuffer(key, rtWidth, rtHeight, autoResize = true, outColor = true, depthTexture) {
-        let attachments = this.renderTargets;
-        let reDescriptors = this.rtDescriptors;
-        if (outColor) {
-            let colorDec = new RTDescriptor();
-            colorDec.loadOp = "clear";
-            this._colorBufferTex = RTResourceMap.createRTTexture(key + RTResourceConfig.colorBufferTex_NAME, rtWidth, rtHeight, GPUTextureFormat.rgba16float, true);
-            attachments.push(this._colorBufferTex);
-            reDescriptors.push(colorDec);
-        }
-        this._compressGBufferTex = new RenderTexture(rtWidth, rtHeight, GPUTextureFormat.rgba32float, false, undefined, 1, 0, true, true);
-        attachments.push(this._compressGBufferTex);
-        if (depthTexture) {
-            this.depthTexture = depthTexture;
-        }
-        else {
-            this.depthTexture = new RenderTexture(rtWidth, rtHeight, GPUTextureFormat.depth24plus, false, undefined, 1, 0, true, true);
-            this.depthTexture.name = key + `_depthTexture`;
-        }
-        let compressGBufferRTDes;
-        compressGBufferRTDes = new RTDescriptor();
-        reDescriptors.push(compressGBufferRTDes);
-    }
-    getPositionMap() {
-        return this.renderTargets[1];
-    }
-    getNormalMap() {
-        return this.renderTargets[2];
-    }
-    getColorTexture() {
-        return this._colorBufferTex;
-    }
-    getCompressGBufferTexture() {
-        return this._compressGBufferTex;
-    }
-    static getGBufferFrame(key, fixedWidth = 0, fixedHeight = 0, outColor = true, depthTexture) {
-        let gBuffer;
-        if (!GBufferFrame.gBufferMap.has(key)) {
-            gBuffer = new GBufferFrame();
-            let size = webGPUContext.presentationSize;
-            gBuffer.createGBuffer(key, fixedWidth == 0 ? size[0] : fixedWidth, fixedHeight == 0 ? size[1] : fixedHeight, fixedWidth != 0 && fixedHeight != 0, outColor, depthTexture);
-            GBufferFrame.gBufferMap.set(key, gBuffer);
-        }
-        else {
-            gBuffer = GBufferFrame.gBufferMap.get(key);
-        }
-        return gBuffer;
-    }
-    static getGUIBufferFrame() {
-        let colorRTFrame = this.getGBufferFrame(this.colorPass_GBuffer);
-        let rtFrame = GBufferFrame.getGBufferFrame(GBufferFrame.gui_GBuffer, 0, 0, true, colorRTFrame.depthTexture);
-        return rtFrame;
-    }
-    clone() {
-        let gBufferFrame = new GBufferFrame();
-        this.clone2Frame(gBufferFrame);
-        return gBufferFrame;
-    }
-}

package/dist/src/gfx/renderJob/frame/ProbeGBufferFrame.d.ts

@@ -1,5 +0,0 @@
-import { RTFrame } from "./RTFrame";
-export declare class ProbeGBufferFrame extends RTFrame {
-    constructor(rtWidth: number, rtHeight: number, autoResize?: boolean);
-    crateGBuffer(rtWidth: number, rtHeight: number, autoResize: boolean): void;
-}

package/dist/src/gfx/renderJob/frame/ProbeGBufferFrame.js

@@ -1,37 +0,0 @@
-import { RenderTexture } from "../../..";
-import { GPUTextureFormat } from "../../graphics/webGpu/WebGPUConst";
-import { RTDescriptor } from "../../graphics/webGpu/descriptor/RTDescriptor";
-import { RTFrame } from "./RTFrame";
-export class ProbeGBufferFrame extends RTFrame {
-    constructor(rtWidth, rtHeight, autoResize = true) {
-        super([], []);
-        this.crateGBuffer(rtWidth, rtHeight, autoResize);
-    }
-    crateGBuffer(rtWidth, rtHeight, autoResize) {
-        let attachments = this.renderTargets;
-        let rtDescriptors = this.rtDescriptors;
-        let positionMap = new RenderTexture(rtWidth, rtHeight, GPUTextureFormat.rgba16float, false, undefined, 1, 0, true, autoResize);
-        positionMap.name = `positionMap`;
-        let posDec = new RTDescriptor();
-        posDec.loadOp = `load`;
-        let normalMap = new RenderTexture(rtWidth, rtHeight, GPUTextureFormat.rgba16float, false, undefined, 1, 0, true, autoResize);
-        normalMap.name = `normalMap`;
-        let normalDec = new RTDescriptor();
-        normalDec.loadOp = `load`;
-        let colorMap = new RenderTexture(rtWidth, rtHeight, GPUTextureFormat.rgba16float, false, undefined, 1, 0, true, autoResize);
-        colorMap.name = `colorMap`;
-        let colorDec = new RTDescriptor();
-        colorDec.loadOp = `load`;
-        let depthTexture = new RenderTexture(rtWidth, rtHeight, GPUTextureFormat.depth24plus, false, undefined, 1, 0, true, autoResize);
-        depthTexture.name = `depthTexture`;
-        let depthDec = new RTDescriptor();
-        depthDec.loadOp = `load`;
-        attachments.push(positionMap);
-        attachments.push(normalMap);
-        attachments.push(colorMap);
-        rtDescriptors.push(posDec);
-        rtDescriptors.push(normalDec);
-        rtDescriptors.push(colorDec);
-        this.depthTexture = depthTexture;
-    }
-}

package/dist/src/gfx/renderJob/frame/RTFrame.d.ts

@@ -1,17 +0,0 @@
-import { RenderTexture } from "../../../textures/RenderTexture";
-import { RTDescriptor } from "../../graphics/webGpu/descriptor/RTDescriptor";
-export declare class RTFrame {
-    label: string;
-    customSize: boolean;
-    renderTargets: RenderTexture[];
-    rtDescriptors: RTDescriptor[];
-    zPreTexture: RenderTexture;
-    depthTexture: RenderTexture;
-    depthViewIndex: number;
-    depthCleanValue: number;
-    depthLoadOp: GPULoadOp;
-    isOutTarget: boolean;
-    constructor(attachments: RenderTexture[], rtDescriptors: RTDescriptor[], depthTexture?: RenderTexture, zPreTexture?: RenderTexture, isOutTarget?: boolean);
-    clone2Frame(rtFrame: RTFrame): void;
-    clone(): RTFrame;
-}

package/dist/src/gfx/renderJob/frame/RTFrame.js

@@ -1,34 +0,0 @@
-import { RTDescriptor } from "../../graphics/webGpu/descriptor/RTDescriptor";
-export class RTFrame {
-    constructor(attachments, rtDescriptors, depthTexture, zPreTexture, isOutTarget = true) {
-        this.customSize = false;
-        this.depthViewIndex = 0;
-        this.depthCleanValue = 1;
-        this.depthLoadOp = `clear`;
-        this.isOutTarget = true;
-        this.renderTargets = attachments;
-        this.rtDescriptors = rtDescriptors;
-        this.depthTexture = depthTexture;
-        this.zPreTexture = zPreTexture;
-        this.isOutTarget = isOutTarget;
-    }
-    clone2Frame(rtFrame) {
-        rtFrame.renderTargets.push(...this.renderTargets.concat());
-        for (let i = 0; i < this.rtDescriptors.length; i++) {
-            const des = this.rtDescriptors[i];
-            let rtDes = new RTDescriptor();
-            rtDes.loadOp = des.loadOp;
-            rtDes.storeOp = des.storeOp;
-            rtDes.clearValue = des.clearValue;
-            rtFrame.rtDescriptors.push(rtDes);
-        }
-        rtFrame.depthTexture = this.depthTexture;
-        rtFrame.zPreTexture = this.zPreTexture;
-        rtFrame.customSize = this.customSize;
-    }
-    clone() {
-        let rtFrame = new RTFrame([], []);
-        this.clone2Frame(rtFrame);
-        return rtFrame;
-    }
-}

package/dist/src/gfx/renderJob/frame/RTResourceMap.d.ts

@@ -1,13 +0,0 @@
-import { ViewQuad } from "../../../core/ViewQuad";
-import { RenderTexture } from "../../../textures/RenderTexture";
-export declare class RTResourceMap {
-    static rtTextureMap: Map<string, RenderTexture>;
-    static rtViewQuad: Map<string, ViewQuad>;
-    static init(): void;
-    static createRTTexture(name: string, rtWidth: number, rtHeight: number, format: GPUTextureFormat, useMipmap?: boolean, sampleCount?: number): RenderTexture;
-    static createRTTextureArray(name: string, rtWidth: number, rtHeight: number, format: GPUTextureFormat, length?: number, useMipmap?: boolean, sampleCount?: number): RenderTexture;
-    static createViewQuad(name: string, shaderVS: string, shaderFS: string, outRtTexture: RenderTexture, multisample?: number): ViewQuad;
-    static getTexture(name: string): RenderTexture;
-    static CreateSplitTexture(id: string): RenderTexture;
-    static WriteSplitColorTexture(id: string): void;
-}

package/dist/src/gfx/renderJob/frame/RTResourceMap.js

@@ -1,71 +0,0 @@
-import { ViewQuad } from "../../../core/ViewQuad";
-import { RTDescriptor } from "../../graphics/webGpu/descriptor/RTDescriptor";
-import { GPUContext } from "../GPUContext";
-import { RTFrame } from "./RTFrame";
-import { RTResourceConfig } from "../config/RTResourceConfig";
-import { RenderTexture } from "../../../textures/RenderTexture";
-export class RTResourceMap {
-    static init() {
-        this.rtTextureMap = new Map();
-        this.rtViewQuad = new Map();
-    }
-    static createRTTexture(name, rtWidth, rtHeight, format, useMipmap = false, sampleCount = 0) {
-        let rt = this.rtTextureMap.get(name);
-        if (!rt) {
-            if (name == RTResourceConfig.colorBufferTex_NAME) {
-                rt = new RenderTexture(rtWidth, rtHeight, format, useMipmap, undefined, 1, sampleCount, false);
-            }
-            else {
-                rt = new RenderTexture(rtWidth, rtHeight, format, useMipmap, undefined, 1, sampleCount, true);
-            }
-            rt.name = name;
-            RTResourceMap.rtTextureMap.set(name, rt);
-        }
-        return rt;
-    }
-    static createRTTextureArray(name, rtWidth, rtHeight, format, length = 1, useMipmap = false, sampleCount = 0) {
-        let rt = this.rtTextureMap.get(name);
-        if (!rt) {
-            rt = new RenderTexture(rtWidth, rtHeight, format, useMipmap, undefined, length, sampleCount);
-            rt.name = name;
-            RTResourceMap.rtTextureMap.set(name, rt);
-        }
-        return rt;
-    }
-    static createViewQuad(name, shaderVS, shaderFS, outRtTexture, multisample = 0) {
-        let rtFrame = new RTFrame([outRtTexture], [new RTDescriptor()]);
-        let viewQuad = new ViewQuad(shaderVS, shaderFS, rtFrame, multisample);
-        RTResourceMap.rtViewQuad.set(name, viewQuad);
-        return viewQuad;
-    }
-    static getTexture(name) {
-        return this.rtTextureMap.get(name);
-    }
-    static CreateSplitTexture(id) {
-        let colorTex = this.getTexture(RTResourceConfig.colorBufferTex_NAME);
-        let tex = this.getTexture(id + "_split");
-        if (!tex) {
-            tex = this.createRTTexture(id + "_split", colorTex.width, colorTex.height, colorTex.format, false);
-        }
-        return tex;
-    }
-    static WriteSplitColorTexture(id) {
-        let colorTex = this.getTexture(RTResourceConfig.colorBufferTex_NAME);
-        let tex = this.getTexture(id + "_split");
-        const commandEncoder = GPUContext.beginCommandEncoder();
-        commandEncoder.copyTextureToTexture({
-            texture: colorTex.getGPUTexture(),
-            mipLevel: 0,
-            origin: { x: 0, y: 0, z: 0 },
-        }, {
-            texture: tex.getGPUTexture(),
-            mipLevel: 0,
-            origin: { x: 0, y: 0, z: 0 },
-        }, {
-            width: tex.width,
-            height: tex.height,
-            depthOrArrayLayers: 1,
-        });
-        GPUContext.endCommandEncoder(commandEncoder);
-    }
-}

package/dist/src/gfx/renderJob/jobs/ForwardRenderJob.d.ts

@@ -1,7 +0,0 @@
-import { View3D } from "../../../core/View3D";
-import { RendererJob } from "./RendererJob";
-export declare class ForwardRenderJob extends RendererJob {
-    constructor(view: View3D);
-    start(): void;
-    debug(): void;
-}

package/dist/src/gfx/renderJob/jobs/ForwardRenderJob.js

@@ -1,45 +0,0 @@
-import { Engine3D } from "../../../Engine3D";
-import { GlobalBindGroup } from "../../graphics/webGpu/core/bindGroups/GlobalBindGroup";
-import { ColorPassRenderer } from "../passRenderer/color/ColorPassRenderer";
-import { GBufferFrame } from "../frame/GBufferFrame";
-import { RendererJob } from "./RendererJob";
-import { DDGIProbeRenderer } from "../passRenderer/ddgi/DDGIProbeRenderer";
-import { GUIPassRenderer } from "../passRenderer/color/GUIPassRenderer";
-export class ForwardRenderJob extends RendererJob {
-    constructor(view) {
-        super(view);
-    }
-    start() {
-        super.start();
-        {
-            let colorPassRenderer = new ColorPassRenderer();
-            let rtFrame = GBufferFrame.getGBufferFrame(GBufferFrame.colorPass_GBuffer);
-            if (Engine3D.setting.render.zPrePass) {
-                rtFrame.zPreTexture =
-                    this.depthPassRenderer.rendererPassState.depthTexture;
-            }
-            colorPassRenderer.setRenderStates(rtFrame);
-            if (Engine3D.setting.gi.enable) {
-                let lightEntries = GlobalBindGroup.getLightEntries(this.view.scene);
-                this.ddgiProbeRenderer = new DDGIProbeRenderer(lightEntries.irradianceVolume);
-                this.ddgiProbeRenderer.setInputTexture([
-                    this.shadowMapPassRenderer.depth2DArrayTexture,
-                    this.pointLightShadowRenderer.cubeArrayTexture,
-                ]);
-                colorPassRenderer.setIrradiance(this.ddgiProbeRenderer.irradianceColorMap, this.ddgiProbeRenderer.irradianceDepthMap);
-                this.rendererMap.addRenderer(this.ddgiProbeRenderer);
-            }
-            this.rendererMap.addRenderer(colorPassRenderer);
-        }
-        {
-            let guiFrame = GBufferFrame.getGUIBufferFrame();
-            let guiPassRenderer = new GUIPassRenderer();
-            guiPassRenderer.setRenderStates(guiFrame);
-            this.rendererMap.addRenderer(guiPassRenderer);
-        }
-        if (Engine3D.setting.render.debug) {
-            this.debug();
-        }
-    }
-    debug() { }
-}

package/dist/src/gfx/renderJob/jobs/RenderMap.d.ts

@@ -1,12 +0,0 @@
-import { RendererBase } from "../passRenderer/RendererBase";
-import { PassType } from "../passRenderer/state/PassType";
-export declare class RendererMap {
-    private map;
-    private passRendererList;
-    constructor();
-    addRenderer(renderer: RendererBase): void;
-    getRenderer(passType: PassType): RendererBase;
-    private addPassRenderer;
-    getAllRenderer(): Map<PassType, RendererBase>;
-    getAllPassRenderer(): RendererBase[];
-}