@rings-webgpu/core 1.0.2 → 1.0.3

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

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

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

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

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

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

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

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

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

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

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

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