@rings-webgpu/core 1.0.6 → 1.0.7

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/types/gfx/renderJob/jobs/RendererJob.d.ts

@@ -0,0 +1,43 @@
+import { View3D } from "../../../core/View3D";
+import { PickFire } from "../../../io/PickFire";
+import { ColorPassRenderer } from "../passRenderer/color/ColorPassRenderer";
+import { OcclusionSystem } from "../occlusion/OcclusionSystem";
+import { ClusterLightingRender } from "../passRenderer/cluster/ClusterLightingRender";
+import { PointLightShadowRenderer } from "../passRenderer/shadow/PointLightShadowRenderer";
+import { ShadowMapPassRenderer } from "../passRenderer/shadow/ShadowMapPassRenderer";
+import { PreDepthPassRenderer } from "../passRenderer/preDepth/PreDepthPassRenderer";
+import { RendererMap } from "./RenderMap";
+import { PostRenderer } from "../passRenderer/post/PostRenderer";
+import { PostBase } from "../post/PostBase";
+import { RendererBase } from "../passRenderer/RendererBase";
+import { Ctor } from "../../../util/Global";
+import { DDGIProbeRenderer } from "../passRenderer/ddgi/DDGIProbeRenderer";
+import { ReflectionRenderer } from "../passRenderer/cubeRenderer/ReflectionRenderer";
+export declare class RendererJob {
+    rendererMap: RendererMap;
+    shadowMapPassRenderer: ShadowMapPassRenderer;
+    pointLightShadowRenderer: PointLightShadowRenderer;
+    ddgiProbeRenderer: DDGIProbeRenderer;
+    postRenderer: PostRenderer;
+    clusterLightingRender: ClusterLightingRender;
+    reflectionRenderer: ReflectionRenderer;
+    occlusionSystem: OcclusionSystem;
+    depthPassRenderer: PreDepthPassRenderer;
+    get colorPassRenderer(): ColorPassRenderer;
+    pauseRender: boolean;
+    pickFire: PickFire;
+    renderState: boolean;
+    protected _view: View3D;
+    constructor(view: View3D);
+    addRenderer<T extends RendererBase>(c: Ctor<T>, param?: any): T;
+    get view(): View3D;
+    set view(view: View3D);
+    start(): void;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    addPost(post: PostBase): PostBase | PostBase[];
+    removePost(post: PostBase | PostBase[]): void;
+    renderFrame(): void;
+    debug(): void;
+}

package/dist/types/gfx/renderJob/occlusion/OcclusionSystem.d.ts

@@ -0,0 +1,16 @@
+import { RenderNode } from "../../../components/renderer/RenderNode";
+import { Camera3D } from "../../../core/Camera3D";
+import { Scene3D } from "../../../core/Scene3D";
+import { CollectInfo } from "../collect/CollectInfo";
+export declare class OcclusionSystem {
+    frustumCullingList: Float32Array;
+    zVisibleList: Float32Array;
+    private _renderList;
+    static enable: boolean;
+    constructor();
+    occlusionRenderNodeTest(index: number): number;
+    zDepthRenderNodeTest(index: number): number;
+    update(camera: Camera3D, scene: Scene3D): void;
+    collect(nodes: CollectInfo, camera: Camera3D): void;
+    renderCommitTesting(camera: Camera3D, renderNode: RenderNode): boolean;
+}

package/dist/types/gfx/renderJob/passRenderer/RenderContext.d.ts

@@ -0,0 +1,20 @@
+import { RTFrame } from "../frame/RTFrame";
+import { RendererPassState } from "./state/RendererPassState";
+export declare class RenderContext {
+    command: GPUCommandEncoder;
+    encoder: GPURenderPassEncoder;
+    private rendererPassStates;
+    private rtFrame;
+    constructor(rtFrame: RTFrame);
+    clean(): void;
+    beginContinueRendererPassState(color_loadOp?: GPULoadOp, depth_loadOp?: GPULoadOp): RendererPassState;
+    get rendererPassState(): RendererPassState;
+    beginOpaqueRenderPass(): void;
+    beginTransparentRenderPass(): void;
+    specialtRenderPass(): void;
+    endRenderPass(): void;
+    begineNewCommand(): GPUCommandEncoder;
+    endCommand(): void;
+    beginNewEncoder(): GPURenderPassEncoder;
+    endEncoder(): void;
+}

package/dist/types/gfx/renderJob/passRenderer/RendererBase.d.ts

@@ -0,0 +1,40 @@
+import { RenderNode } from "../../../components/renderer/RenderNode";
+import { Scene3D } from "../../../core/Scene3D";
+import { View3D } from "../../../core/View3D";
+import { ViewQuad } from "../../../core/ViewQuad";
+import { CEventDispatcher } from "../../../event/CEventDispatcher";
+import { Texture } from "../../graphics/webGpu/core/texture/Texture";
+import { CollectInfo } from "../collect/CollectInfo";
+import { RTFrame } from "../frame/RTFrame";
+import { OcclusionSystem } from "../occlusion/OcclusionSystem";
+import { RendererPassState } from "./state/RendererPassState";
+import { PassType } from "./state/PassType";
+import { RenderContext } from "./RenderContext";
+import { ClusterLightingBuffer } from "./cluster/ClusterLightingBuffer";
+import { RenderTexture } from "../../..";
+export declare class RendererBase extends CEventDispatcher {
+    rendererPassState: RendererPassState;
+    splitRendererPassState: RendererPassState;
+    useRenderBundle: boolean;
+    debugViewQuads: ViewQuad[];
+    debugTextures: Texture[];
+    protected renderContext: RenderContext;
+    protected _rendererType: PassType;
+    protected _rtFrame: RTFrame;
+    get passType(): PassType;
+    set passType(value: PassType);
+    constructor();
+    setRenderStates(rtFrame: RTFrame): void;
+    getRenderContext(rtFrame: RTFrame): RenderContext;
+    setIrradiance(probeIrradianceMap: RenderTexture, probeDepthMap: RenderTexture): void;
+    compute(view: View3D, occlusionSystem: OcclusionSystem): void;
+    render(view: View3D, occlusionSystem: OcclusionSystem, clusterLightingBuffer: ClusterLightingBuffer, maskTr?: boolean): void;
+    protected nodeUpload(collectInfo: CollectInfo, scene: Scene3D, occlusionSystem?: OcclusionSystem): void;
+    protected occlusionRenderNodeTest(i: number, id: number, occlusionSystem: OcclusionSystem): boolean;
+    protected renderOp(encoder: GPURenderPassEncoder, command: GPUCommandEncoder, collectInfo: CollectInfo, scene: Scene3D, occlusionSystem: OcclusionSystem): void;
+    protected renderTr(encoder: GPURenderPassEncoder, command: GPUCommandEncoder, collectInfo: CollectInfo, scene: Scene3D, occlusionSystem: OcclusionSystem): void;
+    protected renderBundleOp(view: View3D, collectInfo: CollectInfo, occlusionSystem: OcclusionSystem, clusterLightingBuffer?: ClusterLightingBuffer): any[];
+    protected renderBundleTr(view: View3D, collectInfo: CollectInfo, occlusionSystem: OcclusionSystem, clusterLightingBuffer?: ClusterLightingBuffer): any[];
+    protected recordRenderBundleNode(view: View3D, encoder: any, nodes: RenderNode[], clusterLightingBuffer?: ClusterLightingBuffer): void;
+    protected drawRenderNodes(view: View3D, encoder: GPURenderPassEncoder, command: GPUCommandEncoder, nodes: RenderNode[], occlusionSystem: OcclusionSystem, clusterLightingBuffer?: ClusterLightingBuffer): void;
+}

package/dist/types/gfx/renderJob/passRenderer/cluster/ClusterConfig.d.ts

@@ -0,0 +1,5 @@
+export declare class ClusterConfig {
+    static clusterTileX: number;
+    static clusterTileY: number;
+    static clusterTileZ: number;
+}

package/dist/types/gfx/renderJob/passRenderer/cluster/ClusterLightingBuffer.d.ts

@@ -0,0 +1,10 @@
+import { ComputeGPUBuffer } from "../../../graphics/webGpu/core/buffer/ComputeGPUBuffer";
+import { UniformGPUBuffer } from "../../../graphics/webGpu/core/buffer/UniformGPUBuffer";
+export declare class ClusterLightingBuffer {
+    clusterBuffer: ComputeGPUBuffer;
+    lightAssignBuffer: ComputeGPUBuffer;
+    assignTableBuffer: ComputeGPUBuffer;
+    clustersUniformBuffer: UniformGPUBuffer;
+    constructor(numClusters: number, maxNumLightsPerCluster: number);
+    update(width: number, height: number, clusterPix: number, clusterTileX: number, clusterTileY: number, clusterTileZ: number, numLights: number, maxNumLightsPerCluster: number, near: number, far: number): void;
+}

package/dist/types/gfx/renderJob/passRenderer/cluster/ClusterLightingRender.d.ts

@@ -0,0 +1,20 @@
+import { View3D } from "../../../../core/View3D";
+import { OcclusionSystem } from "../../occlusion/OcclusionSystem";
+import { RendererBase } from "../RendererBase";
+import { ClusterLightingBuffer } from "./ClusterLightingBuffer";
+/**
+ * 集群光照
+ */
+export declare class ClusterLightingRender extends RendererBase {
+    maxNumLightsPerCluster: number;
+    clusterPix: number;
+    clusterLightingBuffer: ClusterLightingBuffer;
+    private _currentLightCount;
+    private _clusterGenerateCompute;
+    private _clusterLightingCompute;
+    private _useCamera;
+    private resize;
+    constructor(view: View3D);
+    private initCompute;
+    render(view: View3D, occlusionSystem: OcclusionSystem): void;
+}

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

@@ -0,0 +1,12 @@
+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/types/gfx/renderJob/passRenderer/color/GUIPassRenderer.d.ts

@@ -0,0 +1,13 @@
+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/types/gfx/renderJob/passRenderer/cubeRenderer/ReflectionRenderer.d.ts

@@ -0,0 +1,36 @@
+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/types/gfx/renderJob/passRenderer/ddgi/DDGIIrradianceComputePass.d.ts

@@ -0,0 +1,18 @@
+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/types/gfx/renderJob/passRenderer/ddgi/DDGIIrradianceGPUBufferReader.d.ts

@@ -0,0 +1,22 @@
+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/types/gfx/renderJob/passRenderer/ddgi/DDGIIrradianceVolume.d.ts

@@ -0,0 +1,32 @@
+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/types/gfx/renderJob/passRenderer/ddgi/DDGILightingPass.d.ts

@@ -0,0 +1,17 @@
+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/types/gfx/renderJob/passRenderer/ddgi/DDGIMultiBouncePass.d.ts

@@ -0,0 +1,13 @@
+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/types/gfx/renderJob/passRenderer/ddgi/DDGIProbeRenderer.d.ts

@@ -0,0 +1,46 @@
+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/types/gfx/renderJob/passRenderer/ddgi/Probe.d.ts

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

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

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

package/dist/types/gfx/renderJob/passRenderer/preDepth/PreDepthPassRenderer.d.ts

@@ -0,0 +1,16 @@
+import { RenderNode } from "../../../../components/renderer/RenderNode";
+import { View3D } from "../../../../core/View3D";
+import { VirtualTexture } from "../../../../textures/VirtualTexture";
+import { OcclusionSystem } from "../../occlusion/OcclusionSystem";
+import { RendererBase } from "../RendererBase";
+import { ClusterLightingBuffer } from "../cluster/ClusterLightingBuffer";
+import { ZCullingCompute } from "./ZCullingCompute";
+export declare class PreDepthPassRenderer extends RendererBase {
+    zBufferTexture: VirtualTexture;
+    useRenderBundle: boolean;
+    shadowPassCount: number;
+    zCullingCompute: ZCullingCompute;
+    constructor();
+    render(view: View3D, occlusionSystem: OcclusionSystem): void;
+    protected drawRenderNodes(view: View3D, encoder: GPURenderPassEncoder, command: GPUCommandEncoder, nodes: RenderNode[], occlusionSystem: OcclusionSystem, clusterLightingBuffer?: ClusterLightingBuffer): void;
+}