@rings-webgpu/core 1.0.2 → 1.0.3

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

@@ -1,32 +0,0 @@
-import { Matrix4 } from "../../../../math/Matrix4";
-import { Vector3 } from "../../../../math/Vector3";
-import { Probe } from "./Probe";
-import { GlobalIlluminationSetting } from "../../../../setting/GlobalIlluminationSetting";
-import { StorageGPUBuffer } from "../../../graphics/webGpu/core/buffer/StorageGPUBuffer";
-import { UniformGPUBuffer } from "../../../..";
-export declare class DDGIIrradianceVolume {
-    setting: GlobalIlluminationSetting;
-    probesBufferData: Float32Array;
-    probesBuffer: StorageGPUBuffer;
-    isVolumeFrameChange: boolean;
-    private randomOrientation;
-    private startPosition;
-    private isVolumeChange;
-    irradianceVolumeBuffer: UniformGPUBuffer;
-    private readonly directionDistance;
-    private readonly randomSeedCount;
-    private useRandomIndex;
-    private centerDirection;
-    private arroundPositions;
-    updateOrientation(): Matrix4;
-    init(setting: GlobalIlluminationSetting): void;
-    setVolumeDataChange(): void;
-    updateProbes(probes: Probe[]): void;
-    private createFramesBuffer;
-    uploadBuffer(): void;
-    calcPosition(x: number, y: number, z: number, result?: Vector3): Vector3;
-    private debugX;
-    private debugY;
-    private debugZ;
-    private fillIrradianceData;
-}

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

@@ -1,113 +0,0 @@
-import { Matrix4 } from "../../../../math/Matrix4";
-import { Vector3 } from "../../../../math/Vector3";
-import { StorageGPUBuffer } from "../../../graphics/webGpu/core/buffer/StorageGPUBuffer";
-import { UniformGPUBuffer } from "../../../..";
-export class DDGIIrradianceVolume {
-    constructor() {
-        this.isVolumeFrameChange = true;
-        this.startPosition = new Vector3();
-        this.isVolumeChange = true;
-        this.directionDistance = 20;
-        this.randomSeedCount = 3;
-        this.useRandomIndex = 0;
-        this.centerDirection = new Vector3(0, 0, this.directionDistance).normalize(1.0);
-        this.arroundPositions = [];
-        this.debugX = 0;
-        this.debugY = 0;
-        this.debugZ = 0;
-    }
-    updateOrientation() {
-        this.useRandomIndex++;
-        if (this.useRandomIndex >= this.arroundPositions.length)
-            this.useRandomIndex = 0;
-        Matrix4.fromToRotation(this.centerDirection, this.arroundPositions[this.useRandomIndex], this.randomOrientation);
-        return this.randomOrientation;
-    }
-    init(setting) {
-        this.setting = setting;
-        this.randomOrientation = new Matrix4(false);
-        this.randomOrientation.identity();
-        this.irradianceVolumeBuffer = new UniformGPUBuffer(80);
-        this.createFramesBuffer();
-        //center
-        this.arroundPositions.push(this.centerDirection.clone());
-        //random seed
-        for (let i = 0; i < this.randomSeedCount; i++) {
-            let angle = (Math.PI * 2 * i) / this.randomSeedCount;
-            let v = new Vector3(Math.sin(angle), Math.cos(angle), this.directionDistance).normalize(1.0);
-            this.arroundPositions.push(v);
-        }
-    }
-    setVolumeDataChange() {
-        this.isVolumeChange = true;
-    }
-    updateProbes(probes) {
-        let frameArray = this.probesBufferData;
-        for (let probe of probes) {
-            let offset = probe.index * 4;
-            frameArray[offset + 3] = probe.drawCallFrame;
-        }
-    }
-    createFramesBuffer() {
-        if (!this.probesBufferData) {
-            let size = this.setting.probeXCount *
-                this.setting.probeYCount *
-                this.setting.probeZCount;
-            this.probesBufferData = new Float32Array(size * 4);
-            this.probesBufferData.fill(-1);
-            this.probesBuffer = new StorageGPUBuffer(size * 4, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
-        }
-    }
-    uploadBuffer() {
-        if (this.isVolumeChange) {
-            this.fillIrradianceData();
-            this.isVolumeChange = false;
-            this.isVolumeFrameChange = true;
-        }
-        this.probesBuffer.setFloat32Array("uniformFramesBuffer", this.probesBufferData);
-    }
-    calcPosition(x, y, z, result) {
-        let setting = this.setting;
-        let space = this.setting.probeSpace;
-        result = result || new Vector3();
-        result.x =
-            x * space - space * (setting.probeXCount - 1) * 0.5 + setting.offsetX;
-        result.y =
-            y * space - space * (setting.probeYCount - 1) * 0.5 + setting.offsetY;
-        result.z =
-            z * space - space * (setting.probeZCount - 1) * 0.5 + setting.offsetZ;
-        return result;
-    }
-    fillIrradianceData() {
-        let setting = this.setting;
-        let start = this.calcPosition(0, 0, 0, this.startPosition);
-        this.irradianceVolumeBuffer.setFloat("orientationIndex", this.randomOrientation.index);
-        this.irradianceVolumeBuffer.setFloat("hysteresis", setting.hysteresis);
-        this.irradianceVolumeBuffer.setFloat("OctRTSideSize", setting.octRTSideSize);
-        this.irradianceVolumeBuffer.setFloat("OctRTMaxSize", setting.octRTMaxSize);
-        this.irradianceVolumeBuffer.setFloat("startX", start.x);
-        this.irradianceVolumeBuffer.setFloat("startY", start.y);
-        this.irradianceVolumeBuffer.setFloat("startZ", start.z);
-        this.irradianceVolumeBuffer.setFloat("ProbeSpace", setting.probeSpace);
-        this.irradianceVolumeBuffer.setFloat("probeXCount", setting.probeXCount);
-        this.irradianceVolumeBuffer.setFloat("probeYCount", setting.probeYCount);
-        this.irradianceVolumeBuffer.setFloat("probeZCount", setting.probeZCount);
-        this.irradianceVolumeBuffer.setFloat("maxDistance", setting.probeSpace * 1.732); //maxDistance = space * sqrt(3.0);
-        this.irradianceVolumeBuffer.setFloat("depthSharpness", setting.depthSharpness);
-        this.irradianceVolumeBuffer.setFloat("ProbeSourceTextureSize", setting.probeSourceTextureSize);
-        this.irradianceVolumeBuffer.setFloat("ProbeSize", setting.probeSize);
-        this.irradianceVolumeBuffer.setFloat("bounceIntensity", setting.bounceIntensity);
-        this.irradianceVolumeBuffer.setFloat("probeRoughness", setting.probeRoughness);
-        this.irradianceVolumeBuffer.setFloat("normalBias", setting.normalBias);
-        this.irradianceVolumeBuffer.setFloat("irradianceChebyshevBias", setting.irradianceChebyshevBias);
-        this.irradianceVolumeBuffer.setFloat("rayNumber", setting.rayNumber);
-        this.irradianceVolumeBuffer.setFloat("irradianceDistanceBias", setting.irradianceDistanceBias);
-        this.irradianceVolumeBuffer.setFloat("indirectIntensity", setting.indirectIntensity);
-        this.irradianceVolumeBuffer.setFloat("ddgiGamma", setting.ddgiGamma);
-        this.irradianceVolumeBuffer.setFloat("lerpHysteresis", setting.lerpHysteresis);
-        this.irradianceVolumeBuffer.setFloat("debugX", this.debugX);
-        this.irradianceVolumeBuffer.setFloat("debugY", this.debugY);
-        this.irradianceVolumeBuffer.setFloat("debugZ", this.debugZ);
-        this.irradianceVolumeBuffer.apply();
-    }
-}

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

@@ -1,17 +0,0 @@
-import { View3D } from "../../../../core/View3D";
-import { RenderTexture } from "../../../../textures/RenderTexture";
-import { Texture } from "../../../graphics/webGpu/core/texture/Texture";
-import { RendererPassState } from "../state/RendererPassState";
-export declare class DDGILightingPass {
-    private computeShader;
-    private worldPosMap;
-    private worldNormalMap;
-    private colorMap;
-    private shadowMap;
-    private pointShadowMap;
-    lightingTexture: RenderTexture;
-    constructor();
-    private create;
-    setInputs(inputs: Texture[]): void;
-    compute(view: View3D, renderPassState: RendererPassState): void;
-}

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

@@ -1,47 +0,0 @@
-import { DDGILighting_shader } from "../../../../assets/shader/compute/DDGILighting_CSShader";
-import { Engine3D } from "../../../../Engine3D";
-import { RenderTexture } from "../../../../textures/RenderTexture";
-import { GlobalBindGroup } from "../../../graphics/webGpu/core/bindGroups/GlobalBindGroup";
-import { ComputeShader } from "../../../graphics/webGpu/shader/ComputeShader";
-import { GPUTextureFormat } from "../../../graphics/webGpu/WebGPUConst";
-import { GPUContext } from "../../GPUContext";
-export class DDGILightingPass {
-    constructor() {
-        let giSetting = Engine3D.setting.gi;
-        this.lightingTexture = new RenderTexture(giSetting.probeSourceTextureSize, giSetting.probeSourceTextureSize, GPUTextureFormat.rgba16float, false, GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING);
-    }
-    create(view) {
-        let lightUniformEntries = GlobalBindGroup.getLightEntries(view.scene);
-        this.computeShader = new ComputeShader(DDGILighting_shader);
-        let cameraBindGroup = GlobalBindGroup.getCameraGroup(view.camera);
-        this.computeShader.setUniformBuffer("globalUniform", cameraBindGroup.uniformGPUBuffer);
-        this.computeShader.setStorageTexture("outputBuffer", this.lightingTexture);
-        this.computeShader.setStorageBuffer("lightBuffer", lightUniformEntries.storageGPUBuffer);
-        this.computeShader.setStorageBuffer("models", GlobalBindGroup.modelMatrixBindGroup.matrixBufferDst);
-        this.computeShader.setSamplerTexture("positionMap", this.worldPosMap);
-        this.computeShader.setSamplerTexture("normalMap", this.worldNormalMap);
-        this.computeShader.setSamplerTexture("colorMap", this.colorMap);
-        this.computeShader.setSamplerTexture("shadowMap", this.shadowMap);
-        this.computeShader.setSamplerTexture("pointShadowMap", this.pointShadowMap);
-        this.computeShader.setSamplerTexture("prefilterMap", Engine3D.res.defaultSky);
-    }
-    setInputs(inputs) {
-        this.worldPosMap = inputs[0];
-        this.worldNormalMap = inputs[1];
-        this.colorMap = inputs[2];
-        this.shadowMap = inputs[3];
-        this.pointShadowMap = inputs[4];
-    }
-    compute(view, renderPassState) {
-        if (!this.computeShader) {
-            this.create(view);
-        }
-        let command = GPUContext.beginCommandEncoder();
-        let giSetting = Engine3D.setting.gi;
-        this.computeShader.workerSizeX = giSetting.probeSourceTextureSize / 8;
-        this.computeShader.workerSizeY = giSetting.probeSourceTextureSize / 8;
-        this.computeShader.workerSizeZ = 1;
-        GPUContext.computeCommand(command, [this.computeShader]);
-        GPUContext.endCommandEncoder(command);
-    }
-}

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

@@ -1,13 +0,0 @@
-import { View3D } from "../../../../core/View3D";
-import { RenderTexture } from "../../../../textures/RenderTexture";
-import { RendererPassState } from "../state/RendererPassState";
-import { DDGIIrradianceVolume } from "./DDGIIrradianceVolume";
-export declare class DDGIMultiBouncePass {
-    blendTexture: RenderTexture;
-    private volume;
-    private computerShader;
-    constructor(volume: DDGIIrradianceVolume);
-    private initPipeline;
-    setInputs(inputs: RenderTexture[]): void;
-    compute(view: View3D, renderPassState: RendererPassState): void;
-}

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

@@ -1,40 +0,0 @@
-import { MultiBouncePass_cs } from "../../../../assets/shader/compute/MultiBouncePass_cs";
-import { Engine3D } from "../../../../Engine3D";
-import { RenderTexture } from "../../../../textures/RenderTexture";
-import { ComputeShader } from "../../../graphics/webGpu/shader/ComputeShader";
-import { GPUTextureFormat } from "../../../graphics/webGpu/WebGPUConst";
-import { GPUContext } from "../../GPUContext";
-export class DDGIMultiBouncePass {
-    constructor(volume) {
-        this.volume = volume;
-        this.initPipeline();
-    }
-    initPipeline() {
-        let giSetting = Engine3D.setting.gi;
-        this.blendTexture = new RenderTexture(giSetting.probeSourceTextureSize, giSetting.probeSourceTextureSize, GPUTextureFormat.rgba16float, false, GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING);
-        this.computerShader = new ComputeShader(MultiBouncePass_cs);
-        this.computerShader.setStorageTexture("outputBuffer", this.blendTexture);
-        this.computerShader.setUniformBuffer("uniformData", this.volume.irradianceVolumeBuffer);
-    }
-    setInputs(inputs) {
-        let worldNormalMap = inputs[0];
-        let colorMap = inputs[1];
-        let lightingMap = inputs[2];
-        let irradianceMap = inputs[3];
-        this.computerShader.setSamplerTexture("normalMap", worldNormalMap);
-        this.computerShader.setSamplerTexture("colorMap", colorMap);
-        this.computerShader.setSamplerTexture("litMap", lightingMap);
-        this.computerShader.setSamplerTexture("irradianceMap", irradianceMap);
-    }
-    compute(view, renderPassState) {
-        let command = GPUContext.beginCommandEncoder();
-        let setting = this.volume.setting;
-        let probesCount = setting.probeXCount * setting.probeYCount * setting.probeZCount;
-        let probeSourceSize = setting.probeSize;
-        this.computerShader.workerSizeX = (probeSourceSize * 6) / 8;
-        this.computerShader.workerSizeY = probeSourceSize / 8;
-        this.computerShader.workerSizeZ = probesCount;
-        GPUContext.computeCommand(command, [this.computerShader]);
-        GPUContext.endCommandEncoder(command);
-    }
-}

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

@@ -1,46 +0,0 @@
-import { CEvent } from "../../../../event/CEvent";
-import { RenderTexture } from "../../../../textures/RenderTexture";
-import { OcclusionSystem } from "../../occlusion/OcclusionSystem";
-import { RendererBase } from "../RendererBase";
-import { DDGIIrradianceComputePass } from "./DDGIIrradianceComputePass";
-import { DDGIIrradianceVolume } from "./DDGIIrradianceVolume";
-import { DDGIMultiBouncePass } from "./DDGIMultiBouncePass";
-import { Probe } from "./Probe";
-import { Texture } from "../../../graphics/webGpu/core/texture/Texture";
-import { View3D } from "../../../../core/View3D";
-import { DDGILightingPass } from "./DDGILightingPass";
-export type GlobalIrradianceStatus = "none" | "rendering" | "complete";
-export declare let GIRenderStartEvent: CEvent;
-export declare let GIRenderCompleteEvent: CEvent;
-export declare class DDGIProbeRenderer extends RendererBase {
-    private cubeCamera;
-    private volume;
-    private probeCountPerFrame;
-    private nextProbeIndex;
-    private tempProbeList;
-    private isRenderCloudGI?;
-    private probeRenderResult;
-    private renderStatus;
-    positionMap: RenderTexture;
-    normalMap: RenderTexture;
-    colorMap: RenderTexture;
-    probeNext: number;
-    sizeW: number;
-    sizeH: number;
-    lightingPass: DDGILightingPass;
-    bouncePass: DDGIMultiBouncePass;
-    irradianceComputePass: DDGIIrradianceComputePass;
-    irradianceDepthMap: RenderTexture;
-    irradianceColorMap: RenderTexture;
-    constructor(volume: DDGIIrradianceVolume);
-    setInputTexture(textures: Texture[]): void;
-    setIrradianceData(colorData: Float32Array, depthData: Float32Array, width: number, height: number): void;
-    updateProbe(view: View3D, probe: Probe, encoder: GPURenderPassEncoder): void;
-    private renderSceneOnce;
-    render(view: View3D, occlusionSystem: OcclusionSystem): void;
-    startRenderGI(index?: number): void;
-    startRenderCloudGI(): void;
-    private rendProbe;
-    private initIrradianceMap;
-    private writeToTexture;
-}

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

@@ -1,292 +0,0 @@
-import { CubeCamera } from "../../../../core/CubeCamera";
-import { Engine3D } from "../../../../Engine3D";
-import { CEvent } from "../../../../event/CEvent";
-import { RenderTexture } from "../../../../textures/RenderTexture";
-import { EntityCollect } from "../../collect/EntityCollect";
-import { GPUContext } from "../../GPUContext";
-import { ProbeGBufferFrame } from "../../frame/ProbeGBufferFrame";
-import { RendererBase } from "../RendererBase";
-import { PassType } from "../state/PassType";
-import { DDGIIrradianceComputePass } from "./DDGIIrradianceComputePass";
-import { DDGIMultiBouncePass } from "./DDGIMultiBouncePass";
-import { webGPUContext } from "../../../graphics/webGpu/Context3D";
-import { GPUTextureFormat } from "../../../graphics/webGpu/WebGPUConst";
-import { DDGILightingPass } from "./DDGILightingPass";
-export let GIRenderStartEvent = new CEvent("GIRenderStartEvent");
-export let GIRenderCompleteEvent = new CEvent("GIRenderCompleteEvent");
-class ProbeRenderResult {
-}
-export class DDGIProbeRenderer extends RendererBase {
-    constructor(volume) {
-        super();
-        this.probeCountPerFrame = 1;
-        this.nextProbeIndex = -1;
-        this.tempProbeList = [];
-        this.renderStatus = "none";
-        this.probeNext = 128;
-        this.passType = PassType.GI;
-        this.volume = volume;
-        let giSetting = volume.setting;
-        this.cubeCamera = new CubeCamera(0.01, 5000);
-        this.sizeW = giSetting.probeSourceTextureSize;
-        this.sizeH = giSetting.probeSourceTextureSize;
-        this.probeNext = giSetting.probeSourceTextureSize / giSetting.probeSize;
-        this.initIrradianceMap(volume);
-        this.probeRenderResult = new ProbeRenderResult();
-        let probeGBufferFrame = new ProbeGBufferFrame(this.sizeW, this.sizeH, false);
-        this.positionMap = probeGBufferFrame.renderTargets[0];
-        this.normalMap = probeGBufferFrame.renderTargets[1];
-        this.colorMap = probeGBufferFrame.renderTargets[2];
-        this.setRenderStates(probeGBufferFrame);
-    }
-    setInputTexture(textures) {
-        this.lightingPass = new DDGILightingPass();
-        this.bouncePass = new DDGIMultiBouncePass(this.volume);
-        this.irradianceComputePass = new DDGIIrradianceComputePass(this.volume);
-        this.lightingPass.setInputs([
-            this.positionMap,
-            this.normalMap,
-            this.colorMap,
-            textures[0],
-            textures[1],
-        ]);
-        this.bouncePass.setInputs([
-            this.normalMap,
-            this.colorMap,
-            this.lightingPass.lightingTexture,
-            this.irradianceColorMap,
-        ]);
-        this.irradianceComputePass.setTextures([this.positionMap, this.normalMap, this.bouncePass.blendTexture], this.irradianceColorMap, this.irradianceDepthMap);
-    }
-    setIrradianceData(colorData, depthData, width, height) {
-        if (width != this.irradianceColorMap.width ||
-            height != this.irradianceColorMap.height) {
-            console.error("irradiance image size not match !");
-            return;
-        }
-        this.writeToTexture(this.irradianceColorMap, colorData, width, height);
-        this.writeToTexture(this.irradianceDepthMap, depthData, width, height);
-    }
-    updateProbe(view, probe, encoder) {
-        let lights = EntityCollect.instance.getLights(view.scene);
-        let cubeSize = this.volume.setting.probeSize; // cubeSize * 2 * 2 * 2;
-        probe.drawCallFrame += 1;
-        this.cubeCamera.x = probe.x;
-        this.cubeCamera.y = probe.y;
-        this.cubeCamera.z = probe.z;
-        if (this.volume.setting.debugCamera) {
-            this.cubeCamera.x = view.camera.transform.x;
-            this.cubeCamera.y = view.camera.transform.y;
-            this.cubeCamera.z = view.camera.transform.z;
-            this.cubeCamera.rotationX = view.camera.transform.rotationX;
-            this.cubeCamera.rotationY = view.camera.transform.rotationY;
-            this.cubeCamera.rotationZ = view.camera.transform.rotationZ;
-        }
-        else {
-            this.cubeCamera.rotationX = probe.rotationX;
-            this.cubeCamera.rotationY = probe.rotationY;
-            this.cubeCamera.rotationZ = probe.rotationZ;
-        }
-        let cubeCamera = this.cubeCamera;
-        let offsetX = Math.floor(probe.index / this.probeNext) * (cubeSize * 6);
-        let offsetY = Math.floor(probe.index % this.probeNext) * cubeSize;
-        //left***********************/
-        {
-            encoder.setViewport(0 + offsetX, offsetY, cubeSize, cubeSize, 0.0, 1.0);
-            this.renderSceneOnce(view, cubeCamera.right_camera, encoder, lights);
-        }
-        //left***********************/
-        //right***********************/
-        {
-            encoder.setViewport(cubeSize + offsetX, offsetY, cubeSize, cubeSize, 0.0, 1.0);
-            this.renderSceneOnce(view, cubeCamera.left_camera, encoder, lights);
-        }
-        //right***********************/
-        //up***********************/
-        {
-            encoder.setViewport(cubeSize * 2 + offsetX, offsetY, cubeSize, cubeSize, 0.0, 1.0);
-            this.renderSceneOnce(view, cubeCamera.up_camera, encoder, lights);
-        }
-        //up***********************/
-        //down***********************/
-        {
-            encoder.setViewport(cubeSize * 3 + offsetX, offsetY, cubeSize, cubeSize, 0.0, 1.0);
-            this.renderSceneOnce(view, cubeCamera.down_camera, encoder, lights);
-        }
-        //down***********************/
-        //font***********************/
-        {
-            encoder.setViewport(cubeSize * 4 + offsetX, offsetY, cubeSize, cubeSize, 0.0, 1.0);
-            this.renderSceneOnce(view, cubeCamera.front_camera, encoder, lights);
-        }
-        //font***********************/
-        // back***********************/
-        {
-            encoder.setViewport(cubeSize * 5 + offsetX, offsetY, cubeSize, cubeSize, 0.0, 1.0);
-            this.renderSceneOnce(view, cubeCamera.back_camera, encoder, lights);
-        }
-        //back***********************/
-    }
-    renderSceneOnce(view, probeCamera, encoder, lights) {
-        this.volume.uploadBuffer();
-        let collectInfo = EntityCollect.instance.getRenderNodes(view.scene, probeCamera);
-        GPUContext.bindCamera(encoder, probeCamera);
-        let drawMin = Math.max(0, Engine3D.setting.render.drawOpMin);
-        let drawMax = Math.min(Engine3D.setting.render.drawOpMax, collectInfo.opaqueList.length);
-        let viewRenderList = EntityCollect.instance.getRenderShaderCollect(view);
-        for (const renderList of viewRenderList) {
-            let nodeMap = renderList[1];
-            for (const iterator of nodeMap) {
-                let node = iterator[1];
-                if (!node.isDestroyed && node.preInit(this.passType)) {
-                    node.nodeUpdate(view, this.passType, this.rendererPassState, null);
-                    break;
-                }
-            }
-        }
-        for (let i = drawMin; i < drawMax; ++i) {
-            let renderNode = collectInfo.opaqueList[i];
-            if (renderNode.enable &&
-                renderNode.transform.enable &&
-                !renderNode.isDestroyed) {
-                if (!renderNode.preInit(this.passType)) {
-                    renderNode.nodeUpdate(view, this.passType, this.rendererPassState, null);
-                }
-                renderNode.renderPass2(view, this.passType, this.rendererPassState, null, encoder);
-            }
-        }
-        if (EntityCollect.instance.sky) {
-            if (!EntityCollect.instance.sky.preInit(this.passType)) {
-                EntityCollect.instance.sky.nodeUpdate(view, this.passType, this.rendererPassState, null);
-            }
-            EntityCollect.instance.sky.renderPass2(view, this.passType, this.rendererPassState, null, encoder);
-        }
-        drawMin = Math.max(0, Engine3D.setting.render.drawTrMin);
-        drawMax = Math.min(Engine3D.setting.render.drawTrMax, collectInfo.transparentList.length);
-        for (let i = drawMin; i < drawMax; ++i) {
-            let renderNode = collectInfo.transparentList[i];
-            if (renderNode.enable &&
-                renderNode.transform.enable &&
-                !renderNode.isDestroyed) {
-                if (!renderNode.preInit(this.passType)) {
-                    renderNode.nodeUpdate(view, this.passType, this.rendererPassState, null);
-                }
-                renderNode.renderPass2(view, this.passType, this.rendererPassState, null, encoder);
-            }
-        }
-    }
-    render(view, occlusionSystem) {
-        if (!Engine3D.setting.gi.enable)
-            return;
-        this.volume.updateOrientation();
-        this.volume.isVolumeFrameChange = false;
-        this.volume.uploadBuffer();
-        this.rendProbe(view);
-        let probeBeRendered = this.probeRenderResult.count > 0;
-        if (EntityCollect.instance.state.giLightingChange ||
-            probeBeRendered ||
-            Engine3D.setting.gi.realTimeGI) {
-            EntityCollect.instance.state.giLightingChange = false;
-            this.lightingPass.compute(view, this.rendererPassState);
-            this.bouncePass.compute(view, this.rendererPassState);
-            this.irradianceComputePass.compute(view, this.rendererPassState);
-        }
-        if (this.probeRenderResult.complete) {
-            this.dispatchEvent(GIRenderCompleteEvent);
-        }
-    }
-    startRenderGI(index = 0) {
-        if (this.nextProbeIndex == -1 && index == 0) {
-            this.dispatchEvent(GIRenderStartEvent);
-        }
-        this.nextProbeIndex = index;
-        this.renderStatus = "rendering";
-    }
-    startRenderCloudGI() {
-        this.dispatchEvent(GIRenderStartEvent);
-        this.nextProbeIndex = 0;
-        this.renderStatus = "rendering";
-        this.isRenderCloudGI = true;
-    }
-    rendProbe(view) {
-        let autoRenderProbe = Engine3D.setting.gi.autoRenderProbe;
-        //Determine whether to render the probe
-        let execRender = false;
-        if (autoRenderProbe) {
-            if (this.nextProbeIndex == -1) {
-                this.startRenderGI();
-            }
-            execRender = true;
-        }
-        else {
-            execRender = this.renderStatus == "rendering";
-        }
-        //Record the number of probe balls drawn in the current frame
-        this.probeRenderResult.count = 0;
-        this.probeRenderResult.complete = false;
-        //On demand rendering probe
-        if (execRender) {
-            let probeList = EntityCollect.instance.getProbes(view.scene);
-            this.renderContext.clean();
-            this.renderContext.beginOpaqueRenderPass();
-            this.tempProbeList.length = 0;
-            let remainCount = Math.min(this.probeCountPerFrame, probeList.length);
-            this.probeRenderResult.count = remainCount;
-            while (remainCount > 0) {
-                const probe = probeList[this.nextProbeIndex];
-                this.updateProbe(view, probe, this.renderContext.encoder);
-                remainCount--;
-                this.nextProbeIndex++;
-                //
-                if (probe.drawCallFrame < 3) {
-                    this.tempProbeList.push(probe);
-                }
-            }
-            if (this.tempProbeList.length > 0) {
-                this.volume.updateProbes(this.tempProbeList);
-            }
-            let isComplete = this.nextProbeIndex >= probeList.length;
-            //todo
-            if (this.nextProbeIndex >= probeList.length && this.isRenderCloudGI) {
-                this.updateProbe(view, probeList[0], this.renderContext.encoder);
-            }
-            this.renderContext.endRenderPass();
-            if (isComplete) {
-                this.nextProbeIndex = -1;
-                this.renderStatus = "complete";
-                this.probeRenderResult.complete = true;
-            }
-        }
-    }
-    initIrradianceMap(volume) {
-        let setting = volume.setting;
-        let usage = GPUTextureUsage.TEXTURE_BINDING |
-            GPUTextureUsage.STORAGE_BINDING |
-            GPUTextureUsage.COPY_SRC |
-            GPUTextureUsage.COPY_DST;
-        this.irradianceDepthMap = new RenderTexture(setting.octRTMaxSize, setting.octRTMaxSize, GPUTextureFormat.rgba16float, false, usage);
-        this.irradianceDepthMap.name = "irradianceDepthMap";
-        this.irradianceColorMap = new RenderTexture(setting.octRTMaxSize, setting.octRTMaxSize, GPUTextureFormat.rgba16float, false, usage);
-        this.irradianceColorMap.name = "irradianceColorMap";
-    }
-    writeToTexture(texture, array, width, height) {
-        console.log(texture.name);
-        const buffer = webGPUContext.device.createBuffer({
-            size: array.byteLength,
-            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
-        });
-        webGPUContext.device.queue.writeBuffer(buffer, 0, array);
-        const commandEncoder = GPUContext.beginCommandEncoder();
-        commandEncoder.copyBufferToTexture({
-            buffer: buffer,
-            bytesPerRow: width * 16,
-        }, {
-            texture: texture.getGPUTexture(),
-        }, {
-            width: width,
-            height: height,
-            depthOrArrayLayers: 1,
-        });
-        GPUContext.endCommandEncoder(commandEncoder);
-    }
-}

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

@@ -1,6 +0,0 @@
-import { Object3D } from "../../../../core/entities/Object3D";
-export declare class Probe extends Object3D {
-    index: number;
-    drawCallFrame: number;
-    constructor();
-}

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

@@ -1,8 +0,0 @@
-import { Object3D } from "../../../../core/entities/Object3D";
-export class Probe extends Object3D {
-    constructor() {
-        super();
-        this.index = 0;
-        this.drawCallFrame = -1;
-    }
-}

package/dist/src/gfx/renderJob/passRenderer/post/PostRenderer.d.ts

@@ -1,19 +0,0 @@
-import { View3D } from "../../../../core/View3D";
-import { ViewQuad } from "../../../../core/ViewQuad";
-import { Texture } from "../../../graphics/webGpu/core/texture/Texture";
-import { PostBase } from "../../post/PostBase";
-import { RendererBase } from "../RendererBase";
-/**
- * @internal
- * @group Post
- */
-export declare class PostRenderer extends RendererBase {
-    finalQuadView: ViewQuad;
-    postList: Map<string, PostBase>;
-    constructor();
-    initRenderer(): void;
-    attachPost(view: View3D, post: PostBase): void;
-    detachPost(view: View3D, post: PostBase): boolean;
-    render(view: View3D): void;
-    presentContent(view: View3D, texture: Texture): void;
-}