@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/gfx/renderJob/jobs/RenderMap.js

@@ -0,0 +1,29 @@
+export class RendererMap {
+    constructor() {
+        this.map = new Map();
+        this.passRendererList = [];
+    }
+    addRenderer(renderer) {
+        if (!this.map.has(renderer.passType)) {
+            this.map.set(renderer.passType, renderer);
+            if (renderer.passType <= 1 << 3) {
+                this.addPassRenderer(renderer);
+            }
+        }
+        else {
+            console.error("same renderer pass repeat!");
+        }
+    }
+    getRenderer(passType) {
+        return this.map.get(passType);
+    }
+    addPassRenderer(renderer) {
+        this.passRendererList.push(renderer);
+    }
+    getAllRenderer() {
+        return this.map;
+    }
+    getAllPassRenderer() {
+        return this.passRendererList;
+    }
+}

package/dist/src/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/src/gfx/renderJob/jobs/RendererJob.js

@@ -0,0 +1,123 @@
+import { Engine3D } from "../../../Engine3D";
+import { GlobalBindGroup } from "../../graphics/webGpu/core/bindGroups/GlobalBindGroup";
+import { ShadowLightsCollect } from "../collect/ShadowLightsCollect";
+import { GBufferFrame } from "../frame/GBufferFrame";
+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 { ReflectionRenderer } from "../passRenderer/cubeRenderer/ReflectionRenderer";
+import { PassType } from "../passRenderer/state/PassType";
+import { ProfilerUtil } from "../../../util/ProfilerUtil";
+import { FXAAPost } from "../post/FXAAPost";
+export class RendererJob {
+    get colorPassRenderer() {
+        let renderer = this.rendererMap.getRenderer(PassType.COLOR);
+        return renderer;
+    }
+    constructor(view) {
+        this.pauseRender = false;
+        this.renderState = false;
+        this._view = view;
+        this.rendererMap = new RendererMap();
+        this.occlusionSystem = new OcclusionSystem();
+        this.clusterLightingRender = this.addRenderer(ClusterLightingRender, view);
+        this.reflectionRenderer = this.addRenderer(ReflectionRenderer, view);
+        if (Engine3D.setting.render.zPrePass) {
+            this.depthPassRenderer = this.addRenderer(PreDepthPassRenderer);
+        }
+        this.shadowMapPassRenderer = new ShadowMapPassRenderer();
+        this.pointLightShadowRenderer = new PointLightShadowRenderer();
+        this.addPost(new FXAAPost());
+    }
+    addRenderer(c, param) {
+        let renderer;
+        if (param) {
+            renderer = new c(param);
+        }
+        else {
+            renderer = new c();
+        }
+        this.rendererMap.addRenderer(renderer);
+        return renderer;
+    }
+    get view() {
+        return this._view;
+    }
+    set view(view) {
+        this._view = view;
+    }
+    start() {
+        this.renderState = true;
+    }
+    stop() { }
+    pause() {
+        this.pauseRender = true;
+    }
+    resume() {
+        this.pauseRender = false;
+    }
+    addPost(post) {
+        if (!this.postRenderer) {
+            let gbufferFrame = GBufferFrame.getGBufferFrame("ColorPassGBuffer");
+            this.postRenderer = this.addRenderer(PostRenderer);
+            this.postRenderer.setRenderStates(gbufferFrame);
+        }
+        if (post instanceof PostBase) {
+            this.postRenderer.attachPost(this.view, post);
+        }
+        return post;
+    }
+    removePost(post) {
+        if (post instanceof PostBase) {
+            this.postRenderer.detachPost(this.view, post);
+        }
+        else {
+            for (let i = 0; i < post.length; i++) {
+                this.postRenderer.detachPost(this.view, post[i]);
+            }
+        }
+    }
+    renderFrame() {
+        let view = this._view;
+        ProfilerUtil.startView(view);
+        GlobalBindGroup.getLightEntries(view.scene).update(view);
+        GlobalBindGroup.getReflectionEntries(view.scene).update(view);
+        this.occlusionSystem.update(view.camera, view.scene);
+        this.clusterLightingRender.render(view, this.occlusionSystem);
+        if (this.shadowMapPassRenderer) {
+            ShadowLightsCollect.update(view);
+            this.shadowMapPassRenderer.render(view, this.occlusionSystem);
+        }
+        if (this.pointLightShadowRenderer) {
+            this.pointLightShadowRenderer.render(view, this.occlusionSystem);
+        }
+        if (this.depthPassRenderer) {
+            this.depthPassRenderer.compute(view, this.occlusionSystem);
+            this.depthPassRenderer.render(view, this.occlusionSystem);
+        }
+        if (Engine3D.setting.gi.enable && this.ddgiProbeRenderer) {
+            this.ddgiProbeRenderer.compute(view, this.occlusionSystem);
+            this.ddgiProbeRenderer.render(view, this.occlusionSystem);
+        }
+        let passList = this.rendererMap.getAllPassRenderer();
+        for (let i = 0; i < passList.length; i++) {
+            const renderer = passList[i];
+            renderer.compute(view, this.occlusionSystem);
+            renderer.render(view, this.occlusionSystem, this.clusterLightingRender.clusterLightingBuffer, false);
+        }
+        this.postRenderer.render(view);
+        //GUI
+        let guiRenderer = this.rendererMap.getRenderer(PassType.UI);
+        guiRenderer.compute(view, this.occlusionSystem);
+        guiRenderer.render(view, this.occlusionSystem, this.clusterLightingRender.clusterLightingBuffer, false);
+        //output
+        let lastTexture = GBufferFrame.getGUIBufferFrame().getColorTexture();
+        this.postRenderer.presentContent(view, lastTexture);
+    }
+    debug() { }
+}

package/dist/src/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/src/gfx/renderJob/occlusion/OcclusionSystem.js

@@ -0,0 +1,30 @@
+import { Engine3D } from "../../../Engine3D";
+export class OcclusionSystem {
+    static { this.enable = true; }
+    constructor() {
+        this._renderList = new Map();
+    }
+    occlusionRenderNodeTest(index) {
+        if (!Engine3D.setting.occlusionQuery.enable)
+            return 1;
+        if (this.frustumCullingList) {
+            return this.frustumCullingList[index];
+        }
+        else {
+            return 0;
+        }
+    }
+    zDepthRenderNodeTest(index) {
+        if (this.zVisibleList) {
+            return this.zVisibleList[index];
+        }
+        else {
+            return 0;
+        }
+    }
+    update(camera, scene) { }
+    collect(nodes, camera) { }
+    renderCommitTesting(camera, renderNode) {
+        return true;
+    }
+}

package/dist/src/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/src/gfx/renderJob/passRenderer/RenderContext.js

@@ -0,0 +1,68 @@
+import { WebGPUDescriptorCreator } from "../../graphics/webGpu/descriptor/WebGPUDescriptorCreator";
+import { GPUContext } from "../GPUContext";
+export class RenderContext {
+    constructor(rtFrame) {
+        this.rtFrame = rtFrame;
+        this.rendererPassStates = [];
+    }
+    clean() {
+        this.rendererPassStates.length = 0;
+        GPUContext.cleanCache();
+    }
+    beginContinueRendererPassState(color_loadOp = "load", depth_loadOp = "load") {
+        if (this.rendererPassStates.length > 0) {
+            let splitRtFrame = this.rtFrame.clone();
+            for (const iterator of splitRtFrame.rtDescriptors) {
+                iterator.loadOp = `load`;
+            }
+            splitRtFrame.depthLoadOp = depth_loadOp;
+            let splitRendererPassState = WebGPUDescriptorCreator.createRendererPassState(splitRtFrame, color_loadOp);
+            this.rendererPassStates.push(splitRendererPassState);
+            return splitRendererPassState;
+        }
+        else {
+            this.rtFrame.depthLoadOp = depth_loadOp;
+            let splitRendererPassState = WebGPUDescriptorCreator.createRendererPassState(this.rtFrame, color_loadOp);
+            this.rendererPassStates.push(splitRendererPassState);
+            return splitRendererPassState;
+        }
+    }
+    get rendererPassState() {
+        return this.rendererPassStates[this.rendererPassStates.length - 1];
+    }
+    beginOpaqueRenderPass() {
+        this.beginContinueRendererPassState("clear", "clear");
+        this.begineNewCommand();
+        this.beginNewEncoder();
+    }
+    beginTransparentRenderPass() {
+        this.beginContinueRendererPassState("load", "load");
+        this.begineNewCommand();
+        this.beginNewEncoder();
+    }
+    specialtRenderPass() {
+        this.beginContinueRendererPassState("load", "load");
+        this.begineNewCommand();
+        this.beginNewEncoder();
+    }
+    endRenderPass() {
+        this.endEncoder();
+        this.endCommand();
+    }
+    begineNewCommand() {
+        this.command = GPUContext.beginCommandEncoder();
+        return this.command;
+    }
+    endCommand() {
+        GPUContext.endCommandEncoder(this.command);
+        this.command = null;
+    }
+    beginNewEncoder() {
+        this.encoder = GPUContext.beginRenderPass(this.command, this.rendererPassState);
+        return this.encoder;
+    }
+    endEncoder() {
+        GPUContext.endPass(this.encoder);
+        this.encoder = null;
+    }
+}

package/dist/src/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/src/gfx/renderJob/passRenderer/RendererBase.js

@@ -0,0 +1,155 @@
+import { Engine3D } from "../../../Engine3D";
+import { CEventDispatcher } from "../../../event/CEventDispatcher";
+import { WebGPUDescriptorCreator } from "../../graphics/webGpu/descriptor/WebGPUDescriptorCreator";
+import { GPUContext } from "../GPUContext";
+import { EntityCollect } from "../collect/EntityCollect";
+import { RenderContext } from "./RenderContext";
+export class RendererBase extends CEventDispatcher {
+    get passType() {
+        return this._rendererType;
+    }
+    set passType(value) {
+        this._rendererType = value;
+    }
+    constructor() {
+        super();
+        this.useRenderBundle = false;
+        this.debugTextures = [];
+        this.debugViewQuads = [];
+    }
+    setRenderStates(rtFrame) {
+        this._rtFrame = rtFrame;
+        if (rtFrame) {
+            this.rendererPassState =
+                WebGPUDescriptorCreator.createRendererPassState(rtFrame);
+            let splitRtFrame = rtFrame.clone();
+            splitRtFrame.depthLoadOp = "load";
+            for (const iterator of splitRtFrame.rtDescriptors) {
+                iterator.loadOp = `load`;
+            }
+            this.splitRendererPassState =
+                WebGPUDescriptorCreator.createRendererPassState(splitRtFrame);
+        }
+        this.renderContext = new RenderContext(rtFrame);
+    }
+    getRenderContext(rtFrame) {
+        this._rtFrame = rtFrame;
+        let renderContext = new RenderContext(rtFrame);
+        return renderContext;
+    }
+    setIrradiance(probeIrradianceMap, probeDepthMap) {
+        this.rendererPassState.irradianceBuffer = [
+            probeIrradianceMap,
+            probeDepthMap,
+        ];
+    }
+    compute(view, occlusionSystem) { }
+    render(view, occlusionSystem, clusterLightingBuffer, maskTr = false) {
+        GPUContext.cleanCache();
+        let camera = view.camera;
+        let scene = view.scene;
+        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);
+        {
+            let command = GPUContext.beginCommandEncoder();
+            let renderPassEncoder = GPUContext.beginRenderPass(command, this.rendererPassState);
+            if (op_bundleList.length > 0) {
+                renderPassEncoder.executeBundles(op_bundleList);
+            }
+            if (!maskTr && EntityCollect.instance.sky) {
+                GPUContext.bindCamera(renderPassEncoder, camera);
+                EntityCollect.instance.sky.renderPass2(view, this._rendererType, this.rendererPassState, clusterLightingBuffer, renderPassEncoder);
+            }
+            this.drawRenderNodes(view, renderPassEncoder, command, collectInfo.opaqueList, occlusionSystem);
+            GPUContext.endPass(renderPassEncoder);
+            GPUContext.endCommandEncoder(command);
+        }
+        {
+            let command = GPUContext.beginCommandEncoder();
+            let renderPassEncoder = GPUContext.beginRenderPass(command, this.rendererPassState);
+            if (tr_bundleList.length > 0) {
+                renderPassEncoder.executeBundles(tr_bundleList);
+            }
+            if (!maskTr) {
+                GPUContext.bindCamera(renderPassEncoder, camera);
+                this.drawRenderNodes(view, renderPassEncoder, command, collectInfo.transparentList, occlusionSystem);
+            }
+            GPUContext.endPass(renderPassEncoder);
+            GPUContext.endCommandEncoder(command);
+        }
+    }
+    nodeUpload(collectInfo, scene, occlusionSystem) { }
+    occlusionRenderNodeTest(i, id, occlusionSystem) {
+        return occlusionSystem
+            ? occlusionSystem.occlusionRenderNodeTest(i) > 0
+            : true;
+    }
+    renderOp(encoder, command, collectInfo, scene, occlusionSystem) { }
+    renderTr(encoder, command, collectInfo, scene, occlusionSystem) { }
+    renderBundleOp(view, collectInfo, occlusionSystem, clusterLightingBuffer) {
+        let entityBatchCollect = EntityCollect.instance.getOpRenderGroup(view.scene);
+        if (entityBatchCollect) {
+            let bundlerList = [];
+            entityBatchCollect.renderGroup.forEach((v) => {
+                if (v.bundleMap.has(this._rendererType)) {
+                    bundlerList.push(v.bundleMap.get(this._rendererType));
+                }
+                else {
+                    let renderBundleEncoder = GPUContext.recordBundleEncoder(this.rendererPassState.renderBundleEncoderDescriptor);
+                    this.recordRenderBundleNode(view, renderBundleEncoder, v.renderNodes, clusterLightingBuffer);
+                    let newBundle = renderBundleEncoder.finish();
+                    v.bundleMap.set(this._rendererType, newBundle);
+                    bundlerList.push(newBundle);
+                }
+            });
+            return bundlerList;
+        }
+        return [];
+    }
+    renderBundleTr(view, collectInfo, occlusionSystem, clusterLightingBuffer) {
+        let entityBatchCollect = EntityCollect.instance.getTrRenderGroup(view.scene);
+        if (entityBatchCollect) {
+            let bundlerList = [];
+            entityBatchCollect.renderGroup.forEach((v) => {
+                if (v.bundleMap.has(this._rendererType)) {
+                    bundlerList.push(v.bundleMap.get(this._rendererType));
+                }
+                else {
+                    let renderBundleEncoder = GPUContext.recordBundleEncoder(this.rendererPassState.renderBundleEncoderDescriptor);
+                    this.recordRenderBundleNode(view, renderBundleEncoder, v.renderNodes, clusterLightingBuffer);
+                    let newBundle = renderBundleEncoder.finish();
+                    v.bundleMap.set(this._rendererType, newBundle);
+                    bundlerList.push(newBundle);
+                }
+            });
+            return bundlerList;
+        }
+        return [];
+    }
+    recordRenderBundleNode(view, encoder, nodes, clusterLightingBuffer) {
+        GPUContext.bindCamera(encoder, view.camera);
+        GPUContext.bindGeometryBuffer(encoder, nodes[0].geometry);
+        for (let i = 0; i < nodes.length; ++i) {
+            let renderNode = nodes[i];
+            let matrixIndex = renderNode.transform.worldMatrix.index;
+            if (!renderNode.transform.enable)
+                continue;
+            renderNode.recordRenderPass2(view, this._rendererType, this.rendererPassState, clusterLightingBuffer, encoder);
+        }
+    }
+    drawRenderNodes(view, encoder, command, nodes, occlusionSystem, clusterLightingBuffer) {
+        GPUContext.bindCamera(encoder, view.camera);
+        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;
+            renderNode.renderPass2(view, this._rendererType, this.rendererPassState, clusterLightingBuffer, encoder);
+        }
+    }
+}

package/dist/src/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/src/gfx/renderJob/passRenderer/cluster/ClusterConfig.js

@@ -0,0 +1,5 @@
+export class ClusterConfig {
+    static { this.clusterTileX = 16; }
+    static { this.clusterTileY = 16; }
+    static { this.clusterTileZ = 32; }
+}

package/dist/src/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/src/gfx/renderJob/passRenderer/cluster/ClusterLightingBuffer.js

@@ -0,0 +1,29 @@
+import { ComputeGPUBuffer } from "../../../graphics/webGpu/core/buffer/ComputeGPUBuffer";
+import { UniformGPUBuffer } from "../../../graphics/webGpu/core/buffer/UniformGPUBuffer";
+export class ClusterLightingBuffer {
+    constructor(numClusters, maxNumLightsPerCluster) {
+        this.clusterBuffer = new ComputeGPUBuffer(numClusters * /*two vec4*/ 2 * /*vec4*/ 4);
+        this.clustersUniformBuffer = new UniformGPUBuffer(10);
+        this.clustersUniformBuffer.visibility =
+            GPUShaderStage.FRAGMENT | GPUShaderStage.COMPUTE;
+        this.lightAssignBuffer = new ComputeGPUBuffer(numClusters * maxNumLightsPerCluster);
+        this.lightAssignBuffer.visibility =
+            GPUShaderStage.FRAGMENT | GPUShaderStage.COMPUTE;
+        this.assignTableBuffer = new ComputeGPUBuffer(numClusters * 4); // it has start and count
+        this.assignTableBuffer.visibility =
+            GPUShaderStage.FRAGMENT | GPUShaderStage.COMPUTE;
+    }
+    update(width, height, clusterPix, clusterTileX, clusterTileY, clusterTileZ, numLights, maxNumLightsPerCluster, near, far) {
+        this.clustersUniformBuffer.setFloat("clusterTileX", clusterTileX);
+        this.clustersUniformBuffer.setFloat("clusterTileY", clusterTileY);
+        this.clustersUniformBuffer.setFloat("clusterTileZ", clusterTileZ);
+        this.clustersUniformBuffer.setFloat("numLights", numLights);
+        this.clustersUniformBuffer.setFloat("maxNumLightsPerCluster", maxNumLightsPerCluster);
+        this.clustersUniformBuffer.setFloat("near", near);
+        this.clustersUniformBuffer.setFloat("far", far);
+        this.clustersUniformBuffer.setFloat("screenWidth", width);
+        this.clustersUniformBuffer.setFloat("screenHeight", height);
+        this.clustersUniformBuffer.setFloat("clusterPix", clusterPix);
+        this.clustersUniformBuffer.apply();
+    }
+}

package/dist/src/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;
+}