@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/gfx/renderJob/GPUContext.js

@@ -0,0 +1,152 @@
+import { ProfilerUtil } from "../../util/ProfilerUtil";
+import { webGPUContext } from "../graphics/webGpu/Context3D";
+import { GlobalBindGroup } from "../graphics/webGpu/core/bindGroups/GlobalBindGroup";
+export class GPUContext {
+    static { this.drawCount = 0; }
+    static { this.renderPassCount = 0; }
+    static { this.geometryCount = 0; }
+    static { this.pipelineCount = 0; }
+    static { this.matrixCount = 0; }
+    static bindPipeline(encoder, renderShader) {
+        if (GPUContext.lastShader != renderShader) {
+            GPUContext.lastShader = renderShader;
+        }
+        else {
+            return false;
+        }
+        if (GPUContext.lastPipeline != renderShader.pipeline) {
+            GPUContext.lastPipeline = renderShader.pipeline;
+            encoder.setPipeline(renderShader.pipeline);
+        }
+        for (let i = 1; i < renderShader.bindGroups.length; i++) {
+            const bindGroup = renderShader.bindGroups[i];
+            if (bindGroup) {
+                encoder.setBindGroup(i, bindGroup);
+            }
+        }
+        return true;
+    }
+    static bindCamera(encoder, camera) {
+        let cameraBindGroup = GlobalBindGroup.getCameraGroup(camera);
+        encoder.setBindGroup(0, cameraBindGroup.globalBindGroup);
+    }
+    static bindGeometryBuffer(encoder, geometry) {
+        if (this.lastGeometry != geometry) {
+            this.lastGeometry = geometry;
+            if (geometry.indicesBuffer) {
+                encoder.setIndexBuffer(geometry.indicesBuffer.indicesGPUBuffer.buffer, geometry.indicesBuffer.indicesFormat);
+                let vertexBuffer = geometry.vertexBuffer.vertexGPUBuffer;
+                let vertexBufferLayouts = geometry.vertexBuffer.vertexBufferLayouts;
+                for (let i = 0; i < vertexBufferLayouts.length; i++) {
+                    const vbLayout = vertexBufferLayouts[i];
+                    encoder.setVertexBuffer(i, vertexBuffer.buffer, vbLayout.offset, vbLayout.size);
+                }
+            }
+        }
+    }
+    static cleanCache() {
+        this.lastGeometry = null;
+        this.lastPipeline = null;
+        this.lastShader = null;
+    }
+    static createPipeline(gpuRenderPipeline) {
+        ProfilerUtil.countStart("GPUContext", "pipeline");
+        let pipeline = webGPUContext.device.createRenderPipeline(gpuRenderPipeline);
+        return pipeline;
+    }
+    static beginCommandEncoder() {
+        ProfilerUtil.countStart("GPUContext", "beginCommandEncoder");
+        if (this.LastCommand) {
+            webGPUContext.device.queue.submit([this.LastCommand.finish()]);
+        }
+        this.LastCommand = webGPUContext.device.createCommandEncoder();
+        return this.LastCommand;
+    }
+    static endCommandEncoder(command) {
+        if (this.LastCommand == command) {
+            webGPUContext.device.queue.submit([this.LastCommand.finish()]);
+            this.LastCommand = null;
+            ProfilerUtil.countStart("GPUContext", "endCommandEncoder");
+        }
+    }
+    // 预录制
+    static recordBundleEncoder(des) {
+        let bundleEncoder = webGPUContext.device.createRenderBundleEncoder(des);
+        return bundleEncoder;
+    }
+    static beginRenderPass(command, renderPassState) {
+        this.cleanCache();
+        this.renderPassCount++;
+        this.lastRenderPassState = renderPassState;
+        if (renderPassState.depthTexture) {
+            let depth = renderPassState.renderPassDescriptor.depthStencilAttachment;
+            depth.view = renderPassState.depthTexture.getGPUView();
+        }
+        if (renderPassState.renderTargets &&
+            renderPassState.renderTargets.length > 0) {
+            for (let i = 0; i < renderPassState.renderTargets.length; ++i) {
+                const renderTarget = renderPassState.renderTargets[i];
+                let att = renderPassState.renderPassDescriptor.colorAttachments[i];
+                if (renderPassState.multisample > 0 &&
+                    renderPassState.renderTargets.length == 1) {
+                    att.view = renderPassState.multiTexture.createView();
+                    att.resolveTarget = renderTarget.getGPUView();
+                }
+                else {
+                    att.view = renderTarget.getGPUTexture().createView();
+                }
+            }
+            return command.beginRenderPass(renderPassState.renderPassDescriptor);
+        }
+        else {
+            let att0 = renderPassState.renderPassDescriptor.colorAttachments[0];
+            if (att0) {
+                if (renderPassState.multisample > 0) {
+                    att0.view = renderPassState.multiTexture.createView();
+                    att0.resolveTarget = webGPUContext.context
+                        .getCurrentTexture()
+                        .createView();
+                }
+                else {
+                    att0.view = webGPUContext.context.getCurrentTexture().createView();
+                }
+            }
+            return command.beginRenderPass(renderPassState.renderPassDescriptor);
+        }
+    }
+    static drawIndexed(encoder, indexCount, instanceCount, firstIndex, baseVertex, firstInstance) {
+        encoder.drawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
+        this.drawCount++;
+    }
+    static draw(encoder, vertexCount, instanceCount, firstVertex, firstInstance) {
+        encoder.draw(vertexCount, instanceCount, firstVertex, firstInstance);
+        this.drawCount++;
+    }
+    static endPass(encoder) {
+        encoder.insertDebugMarker("end");
+        encoder.end();
+    }
+    static computeCommand(command, computes) {
+        let computePass = command.beginComputePass();
+        for (let i = 0; i < computes.length; i++) {
+            const compute = computes[i];
+            compute.compute(computePass);
+        }
+        computePass.end();
+    }
+    static copyTexture(command, source, dest) {
+        command.copyTextureToTexture({
+            texture: source.getGPUTexture(),
+            mipLevel: 0,
+            origin: { x: 0, y: 0, z: 0 },
+        }, {
+            texture: dest.getGPUTexture(),
+            mipLevel: 0,
+            origin: { x: 0, y: 0, z: 0 },
+        }, {
+            width: dest.width,
+            height: dest.height,
+            depthOrArrayLayers: 1,
+        });
+    }
+}

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

@@ -0,0 +1,7 @@
+import { RenderNode } from "../../../components/renderer/RenderNode";
+export declare class CollectInfo {
+    opaqueList: RenderNode[];
+    transparentList: RenderNode[];
+    sky: RenderNode;
+    clean(): void;
+}

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

@@ -0,0 +1,10 @@
+export class CollectInfo {
+    constructor() {
+        this.opaqueList = [];
+        this.transparentList = [];
+    }
+    clean() {
+        this.opaqueList.length = 0;
+        this.transparentList.length = 0;
+    }
+}

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

@@ -0,0 +1,29 @@
+import { ColliderComponent } from "../../../components/ColliderComponent";
+import { IComponent } from "../../../components/IComponent";
+import { View3D } from "../../../core/View3D";
+import { Object3D } from "../../../core/entities/Object3D";
+export declare class ComponentCollect {
+    static componentsUpdateList: Map<View3D, Map<IComponent, Function>>;
+    static componentsLateUpdateList: Map<View3D, Map<IComponent, Function>>;
+    static componentsBeforeUpdateList: Map<View3D, Map<IComponent, Function>>;
+    static componentsComputeList: Map<View3D, Map<IComponent, Function>>;
+    static componentsEnablePickerList: Map<View3D, Map<ColliderComponent, Function>>;
+    static graphicComponent: Map<View3D, Map<IComponent, Function>>;
+    static waitStartComponent: Map<Object3D, IComponent[]>;
+    private static _init;
+    private static init;
+    static bindUpdate(view: View3D, component: IComponent, call: Function): void;
+    static unBindUpdate(view: View3D, component: IComponent): void;
+    static bindLateUpdate(view: View3D, component: IComponent, call: Function): void;
+    static unBindLateUpdate(view: View3D, component: IComponent): void;
+    static bindBeforeUpdate(view: View3D, component: IComponent, call: Function): void;
+    static unBindBeforeUpdate(view: View3D, component: IComponent): void;
+    static bindCompute(view: View3D, component: IComponent, call: Function): void;
+    static unBindCompute(view: View3D, component: IComponent): void;
+    static bindGraphic(view: View3D, component: IComponent, call: Function): void;
+    static unBindGraphic(view: View3D, component: IComponent): void;
+    static appendWaitStart(component: IComponent): void;
+    static removeWaitStart(obj: Object3D, component: IComponent): void;
+    static bindEnablePick(view: View3D, component: ColliderComponent, call: Function): void;
+    static unBindEnablePick(view: View3D, component: ColliderComponent): void;
+}

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

@@ -0,0 +1,134 @@
+export class ComponentCollect {
+    static { this._init = false; }
+    static init() {
+        if (!this._init) {
+            this._init = true;
+            this.componentsUpdateList = new Map();
+            this.componentsLateUpdateList = new Map();
+            this.componentsBeforeUpdateList = new Map();
+            this.componentsComputeList = new Map();
+            this.componentsEnablePickerList = new Map();
+            this.graphicComponent = new Map();
+            this.waitStartComponent = new Map();
+        }
+    }
+    static bindUpdate(view, component, call) {
+        this.init();
+        let list = this.componentsUpdateList.get(view);
+        if (!list) {
+            list = new Map();
+            this.componentsUpdateList.set(view, list);
+        }
+        list.set(component, call);
+    }
+    static unBindUpdate(view, component) {
+        this.init();
+        let list = this.componentsUpdateList.get(view);
+        if (list) {
+            list.delete(component);
+        }
+    }
+    static bindLateUpdate(view, component, call) {
+        this.init();
+        let list = this.componentsLateUpdateList.get(view);
+        if (!list) {
+            list = new Map();
+            this.componentsLateUpdateList.set(view, list);
+        }
+        list.set(component, call);
+    }
+    static unBindLateUpdate(view, component) {
+        this.init();
+        let list = this.componentsLateUpdateList.get(view);
+        if (list) {
+            list.delete(component);
+        }
+    }
+    static bindBeforeUpdate(view, component, call) {
+        this.init();
+        let list = this.componentsBeforeUpdateList.get(view);
+        if (!list) {
+            list = new Map();
+            this.componentsBeforeUpdateList.set(view, list);
+        }
+        list.set(component, call);
+    }
+    static unBindBeforeUpdate(view, component) {
+        this.init();
+        let list = this.componentsBeforeUpdateList.get(view);
+        if (list) {
+            list.delete(component);
+        }
+    }
+    static bindCompute(view, component, call) {
+        this.init();
+        let list = this.componentsComputeList.get(view);
+        if (!list) {
+            list = new Map();
+            this.componentsComputeList.set(view, list);
+        }
+        list.set(component, call);
+    }
+    static unBindCompute(view, component) {
+        this.init();
+        let list = this.componentsComputeList.get(view);
+        if (list) {
+            list.delete(component);
+        }
+    }
+    static bindGraphic(view, component, call) {
+        this.init();
+        let list = this.graphicComponent.get(view);
+        if (!list) {
+            list = new Map();
+            this.graphicComponent.set(view, list);
+        }
+        list.set(component, call);
+    }
+    static unBindGraphic(view, component) {
+        this.init();
+        let list = this.graphicComponent.get(view);
+        if (list) {
+            list.delete(component);
+        }
+    }
+    static appendWaitStart(component) {
+        this.init();
+        let arr = this.waitStartComponent.get(component.object3D);
+        if (!arr) {
+            this.waitStartComponent.set(component.object3D, [component]);
+        }
+        else {
+            let index = arr.indexOf(component);
+            if (index == -1) {
+                arr.push(component);
+            }
+        }
+    }
+    static removeWaitStart(obj, component) {
+        this.init();
+        let arr = ComponentCollect.waitStartComponent.get(obj);
+        if (arr) {
+            let index = arr.indexOf(component);
+            if (index != -1) {
+                arr.splice(index);
+            }
+        }
+    }
+    static bindEnablePick(view, component, call) {
+        this.init();
+        let list = this.componentsEnablePickerList.get(view);
+        if (!list) {
+            list = new Map();
+            this.componentsEnablePickerList.set(view, list);
+        }
+        list.set(component, call);
+    }
+    static unBindEnablePick(view, component) {
+        this.init();
+        let list = this.componentsEnablePickerList.get(view);
+        if (list) {
+            list.delete(component);
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+import { RenderNode } from "../../../components/renderer/RenderNode";
+import { RenderGroup } from "./RenderGroup";
+export declare class EntityBatchCollect {
+    renderGroup: Map<string, RenderGroup>;
+    constructor();
+    collect_add(node: RenderNode): void;
+}

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

@@ -0,0 +1,24 @@
+export class EntityBatchCollect {
+    constructor() {
+        this.renderGroup = new Map();
+    }
+    collect_add(node) {
+        let g_key = "";
+        let s_key = "";
+        g_key += node.geometry.instanceID;
+        for (let i = 0; i < node.materials.length; i++) {
+            const mat = node.materials[i];
+            s_key += mat.shader.getDefaultColorShader().shaderVariant;
+        }
+        let key = g_key + s_key;
+        if (!this.renderGroup.has(key)) {
+            this.renderGroup.set(key, {
+                bundleMap: new Map(),
+                key: key,
+                renderNodes: [],
+            });
+        }
+        if (this.renderGroup.get(key).renderNodes.indexOf(node) == -1)
+            this.renderGroup.get(key).renderNodes.push(node);
+    }
+}

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

@@ -0,0 +1,48 @@
+import { ILight } from "../../../components/lights/ILight";
+import { Reflection } from "../../../components/renderer/Reflection";
+import { RenderNode } from "../../../components/renderer/RenderNode";
+import { Camera3D } from "../../../core/Camera3D";
+import { Scene3D } from "../../../core/Scene3D";
+import { View3D } from "../../../core/View3D";
+import { Probe } from "../passRenderer/ddgi/Probe";
+import { CollectInfo } from "./CollectInfo";
+import { EntityBatchCollect } from "./EntityBatchCollect";
+export declare class EntityCollect {
+    private static _instance;
+    private _sceneLights;
+    private _sceneGIProbes;
+    private _op_RenderNodes;
+    private _tr_RenderNodes;
+    private _octreeRenderNodes;
+    private _reflections;
+    private _graphics;
+    private _op_renderGroup;
+    private _tr_renderGroup;
+    private _renderShaderCollect;
+    state: {
+        giLightingChange: boolean;
+    };
+    sky: RenderNode;
+    private _collectInfo;
+    private rendererOctree;
+    static get instance(): EntityCollect;
+    constructor();
+    private getPashList;
+    private sortRenderNode;
+    addRenderNode(root: Scene3D, renderNode: RenderNode): void;
+    private getOctree;
+    removeRenderNode(root: Scene3D, renderNode: RenderNode): void;
+    addLight(root: Scene3D, light: ILight): void;
+    removeLight(root: Scene3D, light: ILight): void;
+    getLights(root: Scene3D): ILight[];
+    addGIProbe(root: Scene3D, probe: Probe): void;
+    removeGIProbe(root: Scene3D, probe: Probe): void;
+    getProbes(root: Scene3D): Probe[];
+    getReflections(root: Scene3D): Reflection[];
+    autoSortRenderNodes(scene: Scene3D): this;
+    getRenderNodes(scene: Scene3D, camera: Camera3D): CollectInfo;
+    getOpRenderGroup(scene: Scene3D): EntityBatchCollect;
+    getTrRenderGroup(scene: Scene3D): EntityBatchCollect;
+    getGraphicList(): RenderNode[];
+    getRenderShaderCollect(view: View3D): import("./RenderShaderCollect").RenderShaderList;
+}

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

@@ -0,0 +1,260 @@
+import { Engine3D } from "../../../Engine3D";
+import { BoundingBox } from "../../../core/bound/BoundingBox";
+import { Octree } from "../../../core/tree/octree/Octree";
+import { Vector3 } from "../../../math/Vector3";
+import { zSorterUtil } from "../../../util/ZSorterUtil";
+import { RenderLayerUtil, RenderLayer } from "../config/RenderLayer";
+import { RendererMask } from "../passRenderer/state/RendererMask";
+import { CollectInfo } from "./CollectInfo";
+import { EntityBatchCollect } from "./EntityBatchCollect";
+import { RenderShaderCollect } from "./RenderShaderCollect";
+export class EntityCollect {
+    static get instance() {
+        if (!this._instance) {
+            this._instance = new EntityCollect();
+        }
+        return this._instance;
+    }
+    constructor() {
+        this.state = {
+            giLightingChange: true,
+        };
+        this._sceneLights = new Map();
+        this._sceneGIProbes = new Map();
+        this._op_RenderNodes = new Map();
+        this._tr_RenderNodes = new Map();
+        this._reflections = new Map();
+        this._graphics = [];
+        this._op_renderGroup = new Map();
+        this._tr_renderGroup = new Map();
+        this._collectInfo = new CollectInfo();
+        this._renderShaderCollect = new RenderShaderCollect();
+        this._octreeRenderNodes = new Map();
+    }
+    getPashList(root, renderNode) {
+        if (renderNode.renderOrder < 3000) {
+            return this._op_RenderNodes.get(root);
+        }
+        else if (renderNode.renderOrder >= 3000) {
+            return this._tr_RenderNodes.get(root);
+        }
+    }
+    sortRenderNode(list, renderNode) {
+        for (let i = list.length - 1; i > 0; i--) {
+            const element = list[i];
+            if (element.renderOrder < renderNode.renderOrder) {
+                list.push(renderNode);
+                return;
+            }
+        }
+        list.push(renderNode);
+    }
+    addRenderNode(root, renderNode) {
+        if (!root)
+            return;
+        let isTransparent = renderNode.renderOrder >= 3000;
+        if (renderNode.hasMask(RendererMask.Sky)) {
+            this.sky = renderNode;
+        }
+        else if (renderNode.hasMask(RendererMask.Reflection)) {
+            this.removeRenderNode(root, renderNode);
+            let maps = this._reflections.get(root);
+            if (!maps) {
+                maps = [];
+                this._reflections.set(root, maps);
+                maps.push(renderNode);
+            }
+            if (!maps.includes(renderNode)) {
+                maps.push(renderNode);
+            }
+        }
+        else if (renderNode.hasMask(RendererMask.Graphic3D)) {
+            if (this._graphics.indexOf(renderNode) == -1) {
+                this._graphics.push(renderNode);
+            }
+        }
+        else if (!RenderLayerUtil.hasMask(renderNode.renderLayer, RenderLayer.None)) {
+            this.removeRenderNode(root, renderNode);
+            let group = isTransparent ? this._tr_renderGroup : this._op_renderGroup;
+            if (!group.has(root)) {
+                group.set(root, new EntityBatchCollect());
+            }
+            group.get(root).collect_add(renderNode);
+        }
+        else {
+            this.removeRenderNode(root, renderNode);
+            let map = isTransparent ? this._tr_RenderNodes : this._op_RenderNodes;
+            if (!map.has(root)) {
+                map.set(root, []);
+            }
+            map.get(root).push(renderNode);
+            if (Engine3D.setting.occlusionQuery.octree) {
+                renderNode.attachSceneOctree(this.getOctree(root));
+            }
+            let list = this.getPashList(root, renderNode);
+            let index = list.indexOf(renderNode);
+            if (index == -1) {
+                this.sortRenderNode(list, renderNode);
+            }
+        }
+        renderNode.object3D.renderNode = renderNode;
+        this._renderShaderCollect.collect_add(renderNode);
+    }
+    getOctree(root) {
+        let octree;
+        let setting = Engine3D.setting.occlusionQuery.octree;
+        if (setting) {
+            octree = this._octreeRenderNodes.get(root);
+            if (!octree) {
+                let center = new Vector3(setting.x, setting.y, setting.z);
+                let size = new Vector3(setting.width, setting.height, setting.depth);
+                let bound = new BoundingBox(center, size);
+                octree = new Octree(bound);
+                this._octreeRenderNodes.set(root, octree);
+            }
+        }
+        return octree;
+    }
+    removeRenderNode(root, renderNode) {
+        renderNode.detachSceneOctree();
+        if (renderNode.hasMask(RendererMask.Sky)) {
+            this.sky = null;
+        }
+        else if (renderNode.hasMask(RendererMask.Reflection)) {
+            let maps = this._reflections.get(root);
+            if (maps) {
+                let index = maps.indexOf(renderNode);
+                if (index != -1) {
+                    maps.splice(index, 1);
+                }
+            }
+        }
+        else if (!RenderLayerUtil.hasMask(renderNode.renderLayer, RenderLayer.None)) {
+        }
+        else {
+            let list = this.getPashList(root, renderNode);
+            if (list) {
+                let index = list.indexOf(renderNode);
+                if (index != -1) {
+                    list.splice(index, 1);
+                }
+            }
+        }
+        this._renderShaderCollect.collect_remove(renderNode);
+    }
+    addLight(root, light) {
+        if (!this._sceneLights.has(root)) {
+            this._sceneLights.set(root, [light]);
+        }
+        else {
+            let lights = this._sceneLights.get(root);
+            if (lights.length >= Engine3D.setting.light.maxLight) {
+                console.warn("Alreay meet maxmium light number:", Engine3D.setting.light.maxLight);
+                return;
+            }
+            let hasLight = lights.indexOf(light) != -1;
+            if (!hasLight) {
+                lights.push(light);
+            }
+        }
+    }
+    removeLight(root, light) {
+        if (this._sceneLights.has(root)) {
+            let list = this._sceneLights.get(root);
+            let index = list.indexOf(light);
+            if (index != -1) {
+                list.splice(index, 1);
+            }
+        }
+    }
+    getLights(root) {
+        let list = this._sceneLights.get(root);
+        return list ? list : [];
+    }
+    addGIProbe(root, probe) {
+        if (!this._sceneGIProbes.has(root)) {
+            this._sceneGIProbes.set(root, [probe]);
+        }
+        else {
+            this._sceneGIProbes.get(root).push(probe);
+        }
+    }
+    removeGIProbe(root, probe) {
+        if (this._sceneGIProbes.has(root)) {
+            let list = this._sceneGIProbes.get(root);
+            let index = list.indexOf(probe);
+            if (index != -1) {
+                list.splice(index, 1);
+            }
+        }
+    }
+    getProbes(root) {
+        let list = this._sceneGIProbes.get(root);
+        return list ? list : [];
+    }
+    getReflections(root) {
+        let list = this._reflections.get(root);
+        return list ? list : [];
+    }
+    autoSortRenderNodes(scene) {
+        let renderList = this._tr_RenderNodes.get(scene);
+        if (!renderList)
+            return;
+        let needSort = false;
+        for (const renderNode of renderList) {
+            if (renderNode.isRenderOrderChange || renderNode.needSortOnCameraZ) {
+                needSort = true;
+                break;
+            }
+        }
+        if (needSort) {
+            for (const renderNode of renderList) {
+                let __renderOrder = renderNode.renderOrder;
+                if (renderNode.needSortOnCameraZ) {
+                    let cameraDepth = zSorterUtil.worldToCameraDepth(renderNode.object3D);
+                    cameraDepth = 1 - Math.max(0, Math.min(1, cameraDepth)); //clamp to [0, 1]
+                    __renderOrder += cameraDepth;
+                }
+                renderNode["__renderOrder"] = __renderOrder;
+                renderNode.isRenderOrderChange = false;
+            }
+            renderList.sort((a, b) => {
+                return a["__renderOrder"] > b["__renderOrder"] ? 1 : -1;
+            });
+        }
+        return this;
+    }
+    getRenderNodes(scene, camera) {
+        this.autoSortRenderNodes(scene);
+        this._collectInfo.clean();
+        this._collectInfo.sky = this.sky;
+        if (Engine3D.setting.occlusionQuery.octree) {
+            this.rendererOctree = this.getOctree(scene);
+            this.rendererOctree.getRenderNode(camera.frustum, this._collectInfo);
+        }
+        else {
+            let list2 = this._op_RenderNodes.get(scene);
+            if (list2) {
+                this._collectInfo.opaqueList = list2.concat();
+            }
+            let list5 = this._tr_RenderNodes.get(scene);
+            if (list5) {
+                this._collectInfo.transparentList = list5.concat();
+            }
+        }
+        return this._collectInfo;
+    }
+    getOpRenderGroup(scene) {
+        return this._op_renderGroup.get(scene);
+    }
+    getTrRenderGroup(scene) {
+        return this._tr_renderGroup.get(scene);
+    }
+    getGraphicList() {
+        return this._graphics;
+    }
+    getRenderShaderCollect(view) {
+        let viewList = this._renderShaderCollect.renderShaderUpdateList.get(view);
+        return viewList;
+    }
+}

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

@@ -0,0 +1,7 @@
+import { RenderNode } from "../../../components/renderer/RenderNode";
+import { PassType } from "../passRenderer/state/PassType";
+export type RenderGroup = {
+    key: string;
+    bundleMap: Map<PassType, GPURenderBundle>;
+    renderNodes: RenderNode[];
+};

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

@@ -0,0 +1 @@
+export {};