@rings-webgpu/core 1.0.2 → 1.0.4

package/dist/src/gfx/renderJob/passRenderer/cluster/ClusterLightingRender.js

@@ -1,74 +0,0 @@
-import { GlobalBindGroup } from "../../../graphics/webGpu/core/bindGroups/GlobalBindGroup";
-import { ComputeShader } from "../../../graphics/webGpu/shader/ComputeShader";
-import { webGPUContext } from "../../../graphics/webGpu/Context3D";
-import { EntityCollect } from "../../collect/EntityCollect";
-import { GPUContext } from "../../GPUContext";
-import { RendererBase } from "../RendererBase";
-import { PassType } from "../state/PassType";
-import { ClusterLightingBuffer } from "./ClusterLightingBuffer";
-import { ClusterBoundsSource_cs } from "../../../../assets/shader/cluster/ClusterBoundsSource_cs";
-import { ClusterLighting_cs } from "../../../../assets/shader/cluster/ClusterLighting_cs";
-import { ClusterConfig } from "../../../..";
-/**
- * 集群光照
- */
-export class ClusterLightingRender extends RendererBase {
-    constructor(view) {
-        super();
-        this.maxNumLightsPerCluster = 64;
-        this.clusterPix = 1;
-        this._currentLightCount = 0;
-        this.resize = false;
-        this.passType = PassType.Cluster;
-        this.initCompute(view);
-    }
-    initCompute(view) {
-        this._clusterGenerateCompute = new ComputeShader(ClusterBoundsSource_cs);
-        this._clusterLightingCompute = new ComputeShader(ClusterLighting_cs);
-        let size = webGPUContext.presentationSize;
-        let numClusters = ClusterConfig.clusterTileX *
-            ClusterConfig.clusterTileY *
-            ClusterConfig.clusterTileZ;
-        let camera = view.camera;
-        let near = camera.near;
-        let far = camera.far;
-        this.clusterLightingBuffer = new ClusterLightingBuffer(numClusters, this.maxNumLightsPerCluster);
-        this.clusterLightingBuffer.update(size[0], size[1], this.clusterPix, ClusterConfig.clusterTileX, ClusterConfig.clusterTileY, ClusterConfig.clusterTileZ, 0, this.maxNumLightsPerCluster, near, far);
-        this._clusterGenerateCompute.setUniformBuffer(`clustersUniform`, this.clusterLightingBuffer.clustersUniformBuffer);
-        this._clusterGenerateCompute.setStorageBuffer(`clusterBuffer`, this.clusterLightingBuffer.clusterBuffer);
-        let lightBuffer = GlobalBindGroup.getLightEntries(view.scene);
-        this._clusterLightingCompute.setStorageBuffer(`models`, GlobalBindGroup.modelMatrixBindGroup.matrixBufferDst);
-        this._clusterLightingCompute.setUniformBuffer(`clustersUniform`, this.clusterLightingBuffer.clustersUniformBuffer);
-        this._clusterLightingCompute.setStorageBuffer(`clusterBuffer`, this.clusterLightingBuffer.clusterBuffer);
-        this._clusterLightingCompute.setStorageBuffer(`lightBuffer`, lightBuffer.storageGPUBuffer);
-        this._clusterLightingCompute.setStorageBuffer(`lightAssignBuffer`, this.clusterLightingBuffer.lightAssignBuffer);
-        this._clusterLightingCompute.setStorageBuffer(`assignTable`, this.clusterLightingBuffer.assignTableBuffer);
-        this.resize = true;
-    }
-    render(view, occlusionSystem) {
-        let scene = view.scene;
-        let lights = EntityCollect.instance.getLights(scene);
-        if (this._useCamera != view.camera) {
-            this._useCamera = view.camera;
-            let standBindGroup = GlobalBindGroup.getCameraGroup(this._useCamera);
-            this._clusterGenerateCompute.setUniformBuffer(`globalUniform`, standBindGroup.uniformGPUBuffer);
-            this._clusterLightingCompute.setUniformBuffer(`globalUniform`, standBindGroup.uniformGPUBuffer);
-        }
-        if (this._currentLightCount != lights.length) {
-            this._currentLightCount = lights.length;
-            this.clusterLightingBuffer.clustersUniformBuffer.setFloat("numLights", lights.length);
-            this.clusterLightingBuffer.clustersUniformBuffer.apply();
-            this._clusterGenerateCompute.workerSizeX = ClusterConfig.clusterTileZ;
-            this._clusterLightingCompute.workerSizeX = ClusterConfig.clusterTileZ;
-        }
-        let size = webGPUContext.presentationSize;
-        this.clusterLightingBuffer.update(size[0], size[1], this.clusterPix, ClusterConfig.clusterTileX, ClusterConfig.clusterTileY, ClusterConfig.clusterTileZ, lights.length, this.maxNumLightsPerCluster, view.camera.near, view.camera.far);
-        this.resize = false;
-        let command = GPUContext.beginCommandEncoder();
-        GPUContext.computeCommand(command, [
-            this._clusterGenerateCompute,
-            this._clusterLightingCompute,
-        ]);
-        GPUContext.endCommandEncoder(command);
-    }
-}

package/dist/src/gfx/renderJob/passRenderer/color/ColorPassRenderer.d.ts

@@ -1,12 +0,0 @@
-import { RenderNode } from "../../../../components/renderer/RenderNode";
-import { View3D } from "../../../../core/View3D";
-import { OcclusionSystem } from "../../occlusion/OcclusionSystem";
-import { RenderContext } from "../RenderContext";
-import { RendererBase } from "../RendererBase";
-import { ClusterLightingBuffer } from "../cluster/ClusterLightingBuffer";
-export declare class ColorPassRenderer extends RendererBase {
-    constructor();
-    render(view: View3D, occlusionSystem: OcclusionSystem, clusterLightingBuffer?: ClusterLightingBuffer, maskTr?: boolean): void;
-    drawNodes(view: View3D, renderContext: RenderContext, nodes: RenderNode[], occlusionSystem: OcclusionSystem, clusterLightingBuffer: ClusterLightingBuffer): void;
-    protected occlusionRenderNodeTest(i: number, id: number, occlusionSystem: OcclusionSystem): boolean;
-}

package/dist/src/gfx/renderJob/passRenderer/color/ColorPassRenderer.js

@@ -1,97 +0,0 @@
-import { Engine3D } from "../../../../Engine3D";
-import { ProfilerUtil } from "../../../../util/ProfilerUtil";
-import { GlobalBindGroup } from "../../../graphics/webGpu/core/bindGroups/GlobalBindGroup";
-import { GPUContext } from "../../GPUContext";
-import { EntityCollect } from "../../collect/EntityCollect";
-import { RendererBase } from "../RendererBase";
-import { PassType } from "../state/PassType";
-import { RendererMask } from "../state/RendererMask";
-export class ColorPassRenderer extends RendererBase {
-    constructor() {
-        super();
-        this.passType = PassType.COLOR;
-    }
-    render(view, occlusionSystem, clusterLightingBuffer, maskTr = false) {
-        this.renderContext.clean();
-        let scene = view.scene;
-        let camera = view.camera;
-        GlobalBindGroup.updateCameraGroup(camera);
-        this.rendererPassState.camera3D = camera;
-        let collectInfo = EntityCollect.instance.getRenderNodes(scene, camera);
-        let op_bundleList = this.renderBundleOp(view, collectInfo, occlusionSystem, clusterLightingBuffer);
-        let tr_bundleList = maskTr
-            ? []
-            : this.renderBundleTr(view, collectInfo, occlusionSystem, clusterLightingBuffer);
-        {
-            this.renderContext.beginOpaqueRenderPass();
-            let renderPassEncoder = this.renderContext.encoder;
-            if (op_bundleList.length > 0) {
-                let entityBatchCollect = EntityCollect.instance.getOpRenderGroup(scene);
-                renderPassEncoder.executeBundles(op_bundleList);
-            }
-            if (!maskTr && EntityCollect.instance.sky) {
-                GPUContext.bindCamera(renderPassEncoder, camera);
-                if (!EntityCollect.instance.sky.preInit(this._rendererType)) {
-                    EntityCollect.instance.sky.nodeUpdate(view, this._rendererType, this.rendererPassState, clusterLightingBuffer);
-                }
-                EntityCollect.instance.sky.renderPass2(view, this._rendererType, this.rendererPassState, clusterLightingBuffer, renderPassEncoder);
-            }
-            if (collectInfo.opaqueList) {
-                GPUContext.bindCamera(renderPassEncoder, camera);
-                this.drawNodes(view, this.renderContext, collectInfo.opaqueList, occlusionSystem, clusterLightingBuffer);
-            }
-        }
-        {
-            let renderPassEncoder = this.renderContext.encoder;
-            if (tr_bundleList.length > 0) {
-                renderPassEncoder.executeBundles(tr_bundleList);
-            }
-            if (!maskTr && collectInfo.transparentList) {
-                GPUContext.bindCamera(renderPassEncoder, camera);
-                this.drawNodes(view, this.renderContext, collectInfo.transparentList, occlusionSystem, clusterLightingBuffer);
-            }
-            let graphicsList = EntityCollect.instance.getGraphicList();
-            for (let i = 0; i < graphicsList.length; i++) {
-                const graphic3DRenderNode = graphicsList[i];
-                graphic3DRenderNode.nodeUpdate(view, this._rendererType, this.splitRendererPassState, clusterLightingBuffer);
-                graphic3DRenderNode.renderPass2(view, this._rendererType, this.splitRendererPassState, clusterLightingBuffer, renderPassEncoder);
-            }
-            this.renderContext.endRenderPass();
-            ProfilerUtil.end("ColorPass Draw Transparent");
-        }
-    }
-    drawNodes(view, renderContext, nodes, occlusionSystem, clusterLightingBuffer) {
-        let viewRenderList = EntityCollect.instance.getRenderShaderCollect(view);
-        if (viewRenderList) {
-            for (const renderList of viewRenderList) {
-                let nodeMap = renderList[1];
-                for (const iterator of nodeMap) {
-                    let node = iterator[1];
-                    if (!node.isDestroyed && node.preInit(this._rendererType)) {
-                        node.nodeUpdate(view, this._rendererType, this.rendererPassState, clusterLightingBuffer);
-                        break;
-                    }
-                }
-            }
-            for (let i = Engine3D.setting.render.drawOpMin; i < Math.min(nodes.length, Engine3D.setting.render.drawOpMax); ++i) {
-                let renderNode = nodes[i];
-                if (!renderNode.transform.enable)
-                    continue;
-                if (!renderNode.enable)
-                    continue;
-                if (renderNode.hasMask(RendererMask.UI) &&
-                    !renderNode.isRecievePostEffectUI)
-                    continue;
-                if (renderNode.isDestroyed)
-                    continue;
-                if (!renderNode.preInit(this._rendererType)) {
-                    renderNode.nodeUpdate(view, this._rendererType, this.rendererPassState, clusterLightingBuffer);
-                }
-                renderNode.renderPass(view, this.passType, this.renderContext);
-            }
-        }
-    }
-    occlusionRenderNodeTest(i, id, occlusionSystem) {
-        return occlusionSystem.zDepthRenderNodeTest(id) > 0;
-    }
-}

package/dist/src/gfx/renderJob/passRenderer/color/GUIPassRenderer.d.ts

@@ -1,13 +0,0 @@
-import { RenderNode } from "../../../../components/renderer/RenderNode";
-import { View3D } from "../../../../core/View3D";
-import { OcclusionSystem } from "../../occlusion/OcclusionSystem";
-import { RenderContext } from "../RenderContext";
-import { RendererBase } from "../RendererBase";
-import { ClusterLightingBuffer } from "../cluster/ClusterLightingBuffer";
-export declare class GUIPassRenderer extends RendererBase {
-    constructor();
-    compute(view: View3D, occlusionSystem: OcclusionSystem): void;
-    render(view: View3D, occlusionSystem: OcclusionSystem, clusterLightingBuffer?: ClusterLightingBuffer, maskTr?: boolean): void;
-    drawNodes(view: View3D, renderContext: RenderContext, nodes: RenderNode[], occlusionSystem: OcclusionSystem, clusterLightingBuffer: ClusterLightingBuffer): void;
-    protected occlusionRenderNodeTest(i: number, id: number, occlusionSystem: OcclusionSystem): boolean;
-}

package/dist/src/gfx/renderJob/passRenderer/color/GUIPassRenderer.js

@@ -1,79 +0,0 @@
-import { Engine3D } from "../../../../Engine3D";
-import { GlobalBindGroup } from "../../../graphics/webGpu/core/bindGroups/GlobalBindGroup";
-import { GPUContext } from "../../GPUContext";
-import { EntityCollect } from "../../collect/EntityCollect";
-import { GBufferFrame } from "../../frame/GBufferFrame";
-import { RendererBase } from "../RendererBase";
-import { PassType } from "../state/PassType";
-import { RendererMask } from "../state/RendererMask";
-export class GUIPassRenderer extends RendererBase {
-    constructor() {
-        super();
-        this.passType = PassType.UI;
-    }
-    compute(view, occlusionSystem) {
-        let command = GPUContext.beginCommandEncoder();
-        let src = GPUContext.lastRenderPassState.getLastRenderTexture();
-        let dest = GBufferFrame.getGUIBufferFrame().getColorTexture();
-        GPUContext.copyTexture(command, src, dest);
-        GPUContext.endCommandEncoder(command);
-    }
-    render(view, occlusionSystem, clusterLightingBuffer, maskTr = false) {
-        this.renderContext.clean();
-        let scene = view.scene;
-        let camera = view.camera;
-        GlobalBindGroup.updateCameraGroup(camera);
-        this.rendererPassState.camera3D = camera;
-        let collectInfo = EntityCollect.instance.getRenderNodes(scene, camera);
-        {
-            this.renderContext.specialtRenderPass();
-            let renderPassEncoder = this.renderContext.encoder;
-            if (collectInfo.opaqueList) {
-                GPUContext.bindCamera(renderPassEncoder, camera);
-                this.drawNodes(view, this.renderContext, collectInfo.opaqueList, occlusionSystem, clusterLightingBuffer);
-            }
-        }
-        {
-            let renderPassEncoder = this.renderContext.encoder;
-            if (!maskTr && collectInfo.transparentList) {
-                GPUContext.bindCamera(renderPassEncoder, camera);
-                this.drawNodes(view, this.renderContext, collectInfo.transparentList, occlusionSystem, clusterLightingBuffer);
-            }
-            this.renderContext.endRenderPass();
-        }
-    }
-    drawNodes(view, renderContext, nodes, occlusionSystem, clusterLightingBuffer) {
-        let viewRenderList = EntityCollect.instance.getRenderShaderCollect(view);
-        if (viewRenderList) {
-            for (const renderList of viewRenderList) {
-                let nodeMap = renderList[1];
-                for (const iterator of nodeMap) {
-                    let node = iterator[1];
-                    if (!node.isDestroyed && node.preInit(this._rendererType)) {
-                        node.nodeUpdate(view, this._rendererType, this.rendererPassState, clusterLightingBuffer);
-                        break;
-                    }
-                }
-            }
-            for (let i = Engine3D.setting.render.drawOpMin; i < Math.min(nodes.length, Engine3D.setting.render.drawOpMax); ++i) {
-                let renderNode = nodes[i];
-                if (!renderNode.transform.enable)
-                    continue;
-                if (!renderNode.enable)
-                    continue;
-                if (!renderNode.hasMask(RendererMask.UI) ||
-                    renderNode.isRecievePostEffectUI)
-                    continue;
-                if (renderNode.isDestroyed)
-                    continue;
-                if (!renderNode.preInit(this._rendererType)) {
-                    renderNode.nodeUpdate(view, this._rendererType, this.rendererPassState, clusterLightingBuffer);
-                }
-                renderNode.renderPass(view, this.passType, this.renderContext);
-            }
-        }
-    }
-    occlusionRenderNodeTest(i, id, occlusionSystem) {
-        return occlusionSystem.zDepthRenderNodeTest(id) > 0;
-    }
-}

package/dist/src/gfx/renderJob/passRenderer/cubeRenderer/ReflectionRenderer.d.ts

@@ -1,36 +0,0 @@
-import { Camera3D } from "../../../../core/Camera3D";
-import { OcclusionSystem } from "../../occlusion/OcclusionSystem";
-import { RendererBase } from "../RendererBase";
-import { View3D } from "../../../../core/View3D";
-import { GBufferFrame } from "../../frame/GBufferFrame";
-import { ClusterLightingBuffer } from "../cluster/ClusterLightingBuffer";
-import { RenderContext } from "../RenderContext";
-import { RenderNode } from "../../../../components/renderer/RenderNode";
-import { ComputeShader } from "../../../graphics/webGpu/shader/ComputeShader";
-import { VirtualTexture } from "../../../../textures/VirtualTexture";
-import { UniformGPUBuffer } from "../../../graphics/webGpu/core/buffer/UniformGPUBuffer";
-export declare class ReflectionRenderer extends RendererBase {
-    private cubeCamera;
-    gBuffer: GBufferFrame;
-    sizeW: number;
-    sizeH: number;
-    probeSize: number;
-    probeCount: number;
-    mipCount: number;
-    preFilteredEnvironmentCompute: ComputeShader;
-    outTexture: VirtualTexture;
-    preFilteredEnvironmentUniform: UniformGPUBuffer;
-    private onChange;
-    private needUpdate;
-    /**
-     *
-     * @param volume
-     */
-    constructor();
-    forceUpdate(): void;
-    compute(view: View3D, occlusionSystem: OcclusionSystem): void;
-    render(view: View3D, occlusionSystem: OcclusionSystem, clusterLightingBuffer?: ClusterLightingBuffer, maskTr?: boolean, hasPost?: boolean): void;
-    renderOnce(view: View3D, camera: Camera3D, encoder: any, occlusionSystem: OcclusionSystem, clusterLightingBuffer?: ClusterLightingBuffer, maskTr?: boolean): void;
-    drawNodes(view: View3D, renderContext: RenderContext, nodes: RenderNode[], occlusionSystem: OcclusionSystem, clusterLightingBuffer: ClusterLightingBuffer): void;
-    protected occlusionRenderNodeTest(i: number, id: number, occlusionSystem: OcclusionSystem): boolean;
-}

package/dist/src/gfx/renderJob/passRenderer/cubeRenderer/ReflectionRenderer.js

@@ -1,172 +0,0 @@
-import { CubeCamera } from "../../../../core/CubeCamera";
-import { Engine3D } from "../../../../Engine3D";
-import { EntityCollect } from "../../collect/EntityCollect";
-import { GPUContext } from "../../GPUContext";
-import { RendererBase } from "../RendererBase";
-import { PassType } from "../state/PassType";
-import { GBufferFrame } from "../../frame/GBufferFrame";
-import { RendererMask } from "../state/RendererMask";
-import { PreFilteredEnvironment_cs } from "../../../../assets/shader/compute/PreFilteredEnvironment_cs";
-import { ComputeShader } from "../../../graphics/webGpu/shader/ComputeShader";
-import { VirtualTexture } from "../../../../textures/VirtualTexture";
-import { GPUTextureFormat } from "../../../graphics/webGpu/WebGPUConst";
-import { UniformGPUBuffer } from "../../../graphics/webGpu/core/buffer/UniformGPUBuffer";
-import { GlobalBindGroup } from "../../../graphics/webGpu/core/bindGroups/GlobalBindGroup";
-import { Time } from "../../../../util/Time";
-export class ReflectionRenderer extends RendererBase {
-    /**
-     *
-     * @param volume
-     */
-    constructor() {
-        super();
-        this.sizeW = 0;
-        this.sizeH = 0;
-        this.probeSize = 64;
-        this.probeCount = 32;
-        this.mipCount = 8;
-        this.onChange = true;
-        this.needUpdate = true;
-        this.passType = PassType.REFLECTION;
-        this.cubeCamera = new CubeCamera(0.01, 5000);
-        let mipmap = 1;
-        this.probeSize = Engine3D.setting.reflectionSetting.reflectionProbeSize;
-        this.probeCount =
-            Engine3D.setting.reflectionSetting.reflectionProbeMaxCount;
-        this.sizeW = Engine3D.setting.reflectionSetting.width;
-        this.sizeH = Engine3D.setting.reflectionSetting.height;
-        this.gBuffer = GBufferFrame.getGBufferFrame(GBufferFrame.reflections_GBuffer, this.sizeW, this.sizeH, false);
-        this.setRenderStates(this.gBuffer);
-        this.outTexture = new VirtualTexture(this.probeSize * this.mipCount, this.sizeH, GPUTextureFormat.rgba16float, false, GPUTextureUsage.STORAGE_BINDING |
-            GPUTextureUsage.COPY_DST |
-            GPUTextureUsage.COPY_SRC |
-            GPUTextureUsage.RENDER_ATTACHMENT |
-            GPUTextureUsage.TEXTURE_BINDING, 1, 0, mipmap);
-        this.outTexture.name = "texture_AAA";
-        this.preFilteredEnvironmentUniform = new UniformGPUBuffer(4 + this.probeCount * 4);
-        this.preFilteredEnvironmentUniform.setFloat("probeSize", this.probeSize);
-        this.preFilteredEnvironmentUniform.setFloat("probeCount", this.probeCount);
-        this.preFilteredEnvironmentUniform.setFloat("width", this.sizeW);
-        this.preFilteredEnvironmentUniform.setFloat("height", this.sizeH);
-        this.preFilteredEnvironmentUniform.apply();
-        this.preFilteredEnvironmentCompute = new ComputeShader(PreFilteredEnvironment_cs);
-        this.preFilteredEnvironmentCompute.setSamplerTexture("inputTex", this.gBuffer.getCompressGBufferTexture());
-        this.preFilteredEnvironmentCompute.setStorageTexture("outputTexture", this.outTexture);
-        this.preFilteredEnvironmentCompute.setUniformBuffer("uniformData", this.preFilteredEnvironmentUniform);
-    }
-    forceUpdate() {
-        this.onChange = true;
-    }
-    compute(view, occlusionSystem) {
-        if (this.needUpdate) {
-            this.needUpdate = false;
-            let reflectionEntries = GlobalBindGroup.getReflectionEntries(view.scene);
-            reflectionEntries.reflectionMap = this.outTexture;
-            this.preFilteredEnvironmentCompute.workerSizeX = Math.ceil((this.probeSize * this.mipCount) / 16);
-            this.preFilteredEnvironmentCompute.workerSizeY = Math.ceil(this.sizeH / 16);
-            this.preFilteredEnvironmentCompute.workerSizeZ =
-                this.mipCount * reflectionEntries.count;
-            let command = GPUContext.beginCommandEncoder();
-            GPUContext.computeCommand(command, [this.preFilteredEnvironmentCompute]);
-            GPUContext.endCommandEncoder(command);
-        }
-    }
-    render(view, occlusionSystem, clusterLightingBuffer, maskTr = false, hasPost = false) {
-        this.renderContext.clean();
-        let spaceX = this.probeSize;
-        let spaceY = this.probeSize;
-        let reflections = EntityCollect.instance.getReflections(view.scene);
-        for (let i = 0; i < reflections.length; i++) {
-            let reflection = reflections[i];
-            if ((reflection.autoUpdate && (reflection.needUpdate || this.onChange)) ||
-                Time.frame < 10) {
-                reflection.needUpdate = false;
-                this.needUpdate = true;
-                this.renderContext.beginOpaqueRenderPass();
-                let encoder = this.renderContext.encoder;
-                let offsetY = i * spaceY;
-                reflections[i].transform.updateWorldMatrix();
-                let worldPos = reflections[i].transform.worldPosition;
-                this.cubeCamera.x = worldPos.x;
-                this.cubeCamera.y = worldPos.y;
-                this.cubeCamera.z = worldPos.z;
-                this.cubeCamera.far = 10000; // view.camera.far;
-                this.cubeCamera.transform.updateWorldMatrix();
-                encoder.setViewport(spaceX * 0, offsetY, spaceX, spaceY, 0.0, 1.0);
-                this.renderOnce(view, this.cubeCamera.right_camera, encoder, occlusionSystem, clusterLightingBuffer, maskTr);
-                encoder.setViewport(spaceX * 1, offsetY, spaceX, spaceY, 0.0, 1.0);
-                this.renderOnce(view, this.cubeCamera.left_camera, encoder, occlusionSystem, clusterLightingBuffer, maskTr);
-                encoder.setViewport(spaceX * 2, offsetY, spaceX, spaceY, 0.0, 1.0);
-                this.renderOnce(view, this.cubeCamera.up_camera, encoder, occlusionSystem, clusterLightingBuffer, maskTr);
-                encoder.setViewport(spaceX * 3, offsetY, spaceX, spaceY, 0.0, 1.0);
-                this.renderOnce(view, this.cubeCamera.down_camera, encoder, occlusionSystem, clusterLightingBuffer, maskTr);
-                encoder.setViewport(spaceX * 4, offsetY, spaceX, spaceY, 0.0, 1.0);
-                this.renderOnce(view, this.cubeCamera.front_camera, encoder, occlusionSystem, clusterLightingBuffer, maskTr);
-                encoder.setViewport(spaceX * 5, offsetY, spaceX, spaceY, 0.0, 1.0);
-                this.renderOnce(view, this.cubeCamera.back_camera, encoder, occlusionSystem, clusterLightingBuffer, maskTr);
-                this.renderContext.endRenderPass();
-            }
-        }
-        this.onChange = false;
-    }
-    renderOnce(view, camera, encoder, occlusionSystem, clusterLightingBuffer, maskTr = false) {
-        let scene = view.scene;
-        camera.transform.scene3D = scene;
-        this.rendererPassState.camera3D = camera;
-        let collectInfo = EntityCollect.instance.getRenderNodes(scene, camera);
-        {
-            let renderPassEncoder = encoder;
-            GlobalBindGroup.updateCameraGroup(camera);
-            if (!maskTr && EntityCollect.instance.sky) {
-                GPUContext.bindCamera(renderPassEncoder, camera);
-                if (!EntityCollect.instance.sky.preInit(PassType.REFLECTION)) {
-                    EntityCollect.instance.sky.nodeUpdate(view, PassType.REFLECTION, this.rendererPassState, clusterLightingBuffer);
-                }
-                EntityCollect.instance.sky.renderPass2(view, PassType.REFLECTION, this.rendererPassState, clusterLightingBuffer, renderPassEncoder);
-            }
-            if (collectInfo.opaqueList) {
-                GPUContext.bindCamera(renderPassEncoder, camera);
-                this.drawNodes(view, this.renderContext, collectInfo.opaqueList, occlusionSystem, clusterLightingBuffer);
-            }
-            if (!maskTr && collectInfo.transparentList) {
-                GPUContext.bindCamera(renderPassEncoder, camera);
-                this.drawNodes(view, this.renderContext, collectInfo.transparentList, occlusionSystem, clusterLightingBuffer);
-            }
-        }
-    }
-    drawNodes(view, renderContext, nodes, occlusionSystem, clusterLightingBuffer) {
-        let viewRenderList = EntityCollect.instance.getRenderShaderCollect(view);
-        if (viewRenderList) {
-            for (const renderList of viewRenderList) {
-                let nodeMap = renderList[1];
-                for (const iterator of nodeMap) {
-                    let node = iterator[1];
-                    if (node.hasMask(RendererMask.ReflectionDebug))
-                        continue;
-                    if (!node.isDestroyed && node.preInit(PassType.REFLECTION)) {
-                        node.nodeUpdate(view, PassType.REFLECTION, this.rendererPassState, clusterLightingBuffer);
-                        break;
-                    }
-                }
-            }
-            for (let i = 0; i < nodes.length; i++) {
-                let renderNode = nodes[i];
-                if (renderNode.hasMask(RendererMask.ReflectionDebug))
-                    continue;
-                if (!renderNode.transform.enable)
-                    continue;
-                if (!renderNode.enable)
-                    continue;
-                if (renderNode.isDestroyed)
-                    continue;
-                if (!renderNode.preInit(PassType.REFLECTION)) {
-                    renderNode.nodeUpdate(view, PassType.REFLECTION, this.rendererPassState, clusterLightingBuffer);
-                }
-                renderNode.renderPass(view, PassType.REFLECTION, this.renderContext);
-            }
-        }
-    }
-    occlusionRenderNodeTest(i, id, occlusionSystem) {
-        return true;
-    }
-}

package/dist/src/gfx/renderJob/passRenderer/ddgi/DDGIIrradianceComputePass.d.ts

@@ -1,18 +0,0 @@
-import { View3D } from "../../../../core/View3D";
-import { RenderTexture } from "../../../../textures/RenderTexture";
-import { RendererPassState } from "../state/RendererPassState";
-import { DDGIIrradianceVolume } from "./DDGIIrradianceVolume";
-export declare class DDGIIrradianceComputePass {
-    private irradianceBuffer;
-    private depthBuffer;
-    private probeIrradianceMap;
-    private probeDepthMap;
-    private volume;
-    private computeShader;
-    private depthRaysBuffer;
-    constructor(volume: DDGIIrradianceVolume);
-    private initPipeline;
-    setTextures(inputs: RenderTexture[], probeIrradianceMap: RenderTexture, probeDepthMap: RenderTexture): void;
-    readBuffer(): Float32Array<ArrayBufferLike>;
-    compute(view: View3D, renderPassState: RendererPassState): void;
-}

package/dist/src/gfx/renderJob/passRenderer/ddgi/DDGIIrradianceComputePass.js

@@ -1,52 +0,0 @@
-import { DDGIIrradiance_shader } from "../../../../assets/shader/compute/DDGIIrradiance_Cs";
-import { Engine3D } from "../../../../Engine3D";
-import { GlobalBindGroup } from "../../../graphics/webGpu/core/bindGroups/GlobalBindGroup";
-import { StorageGPUBuffer } from "../../../graphics/webGpu/core/buffer/StorageGPUBuffer";
-import { ComputeShader } from "../../../graphics/webGpu/shader/ComputeShader";
-import { EntityCollect } from "../../collect/EntityCollect";
-import { GPUContext } from "../../GPUContext";
-export class DDGIIrradianceComputePass {
-    constructor(volume) {
-        this.volume = volume;
-        this.initPipeline();
-    }
-    initPipeline() {
-        this.computeShader = new ComputeShader(DDGIIrradiance_shader);
-        let giSetting = Engine3D.setting.gi;
-        let pixelCount = giSetting.octRTMaxSize * giSetting.octRTMaxSize;
-        this.irradianceBuffer = new StorageGPUBuffer(pixelCount * 4, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
-        this.computeShader.setStorageBuffer(`irradianceBuffer`, this.irradianceBuffer);
-        this.depthBuffer = new StorageGPUBuffer(pixelCount * 4, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
-        this.computeShader.setStorageBuffer(`depthBuffer`, this.depthBuffer);
-        this.depthRaysBuffer = new StorageGPUBuffer(4096 * 4 * 2 * 2 * 2, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC);
-        this.computeShader.setStorageBuffer(`depthRaysBuffer`, this.depthRaysBuffer);
-        this.computeShader.setStorageBuffer(`probes`, this.volume.probesBuffer);
-        this.computeShader.setUniformBuffer(`uniformData`, this.volume.irradianceVolumeBuffer);
-        this.computeShader.setStorageBuffer("models", GlobalBindGroup.modelMatrixBindGroup.matrixBufferDst);
-    }
-    setTextures(inputs, probeIrradianceMap, probeDepthMap) {
-        this.probeIrradianceMap = probeIrradianceMap;
-        this.probeDepthMap = probeDepthMap;
-        let worldPosMap = inputs[0];
-        let worldNormalMap = inputs[1];
-        let colorMap = inputs[2];
-        this.computeShader.setStorageTexture(`probeIrradianceMap`, this.probeIrradianceMap);
-        this.computeShader.setStorageTexture(`probeDepthMap`, this.probeDepthMap);
-        this.computeShader.setSamplerTexture(`positionMap`, worldPosMap);
-        this.computeShader.setSamplerTexture(`normalMap`, worldNormalMap);
-        this.computeShader.setSamplerTexture(`colorMap`, colorMap);
-    }
-    readBuffer() {
-        return this.depthRaysBuffer.readBuffer();
-    }
-    compute(view, renderPassState) {
-        let setting = this.volume.setting;
-        let command = GPUContext.beginCommandEncoder();
-        let probes = EntityCollect.instance.getProbes(view.scene);
-        this.computeShader.workerSizeX = setting.octRTSideSize / 8;
-        this.computeShader.workerSizeY = setting.octRTSideSize / 8;
-        this.computeShader.workerSizeZ = probes.length;
-        GPUContext.computeCommand(command, [this.computeShader]);
-        GPUContext.endCommandEncoder(command);
-    }
-}

package/dist/src/gfx/renderJob/passRenderer/ddgi/DDGIIrradianceGPUBufferReader.d.ts

@@ -1,22 +0,0 @@
-import { CEvent } from "../../../../event/CEvent";
-import { CEventDispatcher } from "../../../../event/CEventDispatcher";
-import { RenderTexture } from "../../../../textures/RenderTexture";
-import { DDGIProbeRenderer } from "./DDGIProbeRenderer";
-export declare let IrradianceDataReaderCompleteEvent: CEvent;
-/**
- * 动态漫反射全局光照,探头渲染结果的GPU缓冲区读取器
- */
-export declare class DDGIIrradianceGPUBufferReader extends CEventDispatcher {
-    private readFlag;
-    private probeRenderer;
-    private opColorBuffer;
-    private opDepthBuffer;
-    private srcColorMap;
-    private srcDepthMap;
-    opDepthArray: Float32Array;
-    opColorArray: Float32Array;
-    initReader(probeRender: DDGIProbeRenderer, colorMap: RenderTexture, depthMap: RenderTexture): void;
-    private onProbeRenderComplete;
-    private static read;
-}
-export declare let irradianceDataReader: DDGIIrradianceGPUBufferReader;

package/dist/src/gfx/renderJob/passRenderer/ddgi/DDGIIrradianceGPUBufferReader.js

@@ -1,68 +0,0 @@
-import { Engine3D } from "../../../../Engine3D";
-import { CEvent } from "../../../../event/CEvent";
-import { CEventDispatcher } from "../../../../event/CEventDispatcher";
-import { webGPUContext } from "../../../graphics/webGpu/Context3D";
-import { GPUContext } from "../../GPUContext";
-import { GIRenderCompleteEvent, GIRenderStartEvent, } from "./DDGIProbeRenderer";
-export let IrradianceDataReaderCompleteEvent = new CEvent("IrradianceDataReaderCompleteEvent");
-/**
- * 动态漫反射全局光照,探头渲染结果的GPU缓冲区读取器
- */
-export class DDGIIrradianceGPUBufferReader extends CEventDispatcher {
-    constructor() {
-        super(...arguments);
-        this.readFlag = false;
-    }
-    initReader(probeRender, colorMap, depthMap) {
-        this.probeRenderer = probeRender;
-        this.srcColorMap = colorMap;
-        this.srcDepthMap = depthMap;
-        let giSetting = Engine3D.setting.gi;
-        let pixelCount = giSetting.octRTMaxSize * giSetting.octRTMaxSize;
-        this.opColorBuffer = webGPUContext.device.createBuffer({
-            size: pixelCount * 4 * 4,
-            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
-            mappedAtCreation: false,
-        });
-        this.opColorArray = new Float32Array(pixelCount * 4);
-        this.opDepthBuffer = webGPUContext.device.createBuffer({
-            size: pixelCount * 4 * 4,
-            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
-            mappedAtCreation: false,
-        });
-        this.opDepthArray = new Float32Array(pixelCount * 4);
-        this.probeRenderer.addEventListener(GIRenderCompleteEvent.type, () => {
-            this.onProbeRenderComplete();
-        }, this);
-        this.probeRenderer.addEventListener(GIRenderStartEvent.type, () => {
-            console.log("GIRenderStartEvent");
-        }, this);
-    }
-    async onProbeRenderComplete() {
-        console.log("GIRenderCompleteEvent");
-        if (!this.readFlag) {
-            this.readFlag = true;
-            let startTime = Date.now();
-            console.log("irradianceDataReader start reading ");
-            await DDGIIrradianceGPUBufferReader.read(this.srcColorMap.getGPUTexture(), this.opColorBuffer, this.opColorArray);
-            await DDGIIrradianceGPUBufferReader.read(this.srcDepthMap.getGPUTexture(), this.opDepthBuffer, this.opDepthArray);
-            this.readFlag = false;
-            console.log("process time :", Date.now() - startTime);
-            console.log("irradianceDataReader read complete");
-            this.dispatchEvent(IrradianceDataReaderCompleteEvent);
-        }
-        else {
-            console.log("irradianceDataReader is reading yet!!!");
-        }
-    }
-    static async read(srcTexture, dstBuffer, output) {
-        let command = GPUContext.beginCommandEncoder();
-        command.copyTextureToBuffer({ texture: srcTexture }, { buffer: dstBuffer, bytesPerRow: srcTexture.width * 16 }, [srcTexture.width, srcTexture.height]);
-        GPUContext.endCommandEncoder(command);
-        await dstBuffer.mapAsync(GPUMapMode.READ);
-        const copyArrayBuffer = dstBuffer.getMappedRange();
-        output.set(new Float32Array(copyArrayBuffer), 0);
-        dstBuffer.unmap();
-    }
-}
-export let irradianceDataReader = new DDGIIrradianceGPUBufferReader();