@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/gfx/renderJob/passRenderer/post/PostRenderer.js

@@ -0,0 +1,61 @@
+import { ShaderLib } from "../../../../assets/shader/ShaderLib";
+import { FullQuad_vert_wgsl } from "../../../../assets/shader/quad/Quad_shader";
+import { ViewQuad } from "../../../../core/ViewQuad";
+import { GPUContext } from "../../GPUContext";
+import { RTFrame } from "../../frame/RTFrame";
+import { RendererBase } from "../RendererBase";
+import { PassType } from "../state/PassType";
+/**
+ * @internal
+ * @group Post
+ */
+export class PostRenderer extends RendererBase {
+    constructor() {
+        super();
+        this._rendererType = PassType.POST;
+        this.postList = new Map();
+        this.initRenderer();
+    }
+    initRenderer() {
+        ShaderLib.register("FullQuad_vert_wgsl", FullQuad_vert_wgsl);
+        this.finalQuadView = new ViewQuad(`Quad_vert_wgsl`, `Quad_frag_wgsl`, new RTFrame([], []), 0, false);
+    }
+    attachPost(view, post) {
+        post.postRenderer = this;
+        let clsName = post.constructor.name;
+        let has = this.postList.get(clsName);
+        if (!has) {
+            this.postList.set(clsName, post);
+            post.onAttach(view);
+        }
+    }
+    detachPost(view, post) {
+        let clsName = post.constructor.name;
+        let has = this.postList.get(clsName);
+        if (has) {
+            this.postList.delete(clsName);
+            post.onDetach(view);
+            post.postRenderer = null;
+        }
+        return has != null;
+    }
+    render(view) {
+        this.postList.forEach((v) => {
+            if (v.enable) {
+                v.compute(view);
+            }
+        });
+        let command = GPUContext.beginCommandEncoder();
+        this.postList.forEach((v) => {
+            if (v.enable) {
+                v.render(view, command);
+            }
+        });
+        GPUContext.endCommandEncoder(command);
+    }
+    presentContent(view, texture) {
+        let command = GPUContext.beginCommandEncoder();
+        this.finalQuadView.renderToViewQuad(view, this.finalQuadView, command, texture);
+        GPUContext.endCommandEncoder(command);
+    }
+}

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

package/dist/src/gfx/renderJob/passRenderer/preDepth/PreDepthPassRenderer.js

@@ -0,0 +1,80 @@
+import { Engine3D } from "../../../../Engine3D";
+import { ProfilerUtil } from "../../../../util/ProfilerUtil";
+import { webGPUContext } from "../../../graphics/webGpu/Context3D";
+import { GPUTextureFormat } from "../../../graphics/webGpu/WebGPUConst";
+import { RTDescriptor } from "../../../graphics/webGpu/descriptor/RTDescriptor";
+import { GPUContext } from "../../GPUContext";
+import { EntityCollect } from "../../collect/EntityCollect";
+import { RTResourceConfig } from "../../config/RTResourceConfig";
+import { RTFrame } from "../../frame/RTFrame";
+import { RTResourceMap } from "../../frame/RTResourceMap";
+import { RendererBase } from "../RendererBase";
+import { PassType } from "../state/PassType";
+export class PreDepthPassRenderer extends RendererBase {
+    constructor() {
+        super();
+        this.useRenderBundle = false;
+        this.passType = PassType.DEPTH;
+        let size = webGPUContext.presentationSize;
+        let scale = 1;
+        this.zBufferTexture = RTResourceMap.createRTTexture(RTResourceConfig.zBufferTexture_NAME, Math.floor(size[0] * scale), Math.floor(size[1] * scale), GPUTextureFormat.rgba16float, false);
+        let rtDec = new RTDescriptor();
+        rtDec.clearValue = [0, 0, 0, 0];
+        rtDec.loadOp = `clear`;
+        let rtFrame = new RTFrame([], [], RTResourceMap.createRTTexture(RTResourceConfig.zPreDepthTexture_NAME, Math.floor(size[0]), Math.floor(size[1]), GPUTextureFormat.depth32float, false), null, false);
+        this.setRenderStates(rtFrame);
+    }
+    render(view, occlusionSystem) {
+        let camera = view.camera;
+        let scene = view.scene;
+        GPUContext.cleanCache();
+        ProfilerUtil.start("DepthPass Renderer");
+        let scene3D = scene;
+        this.rendererPassState.camera3D = camera;
+        let collectInfo = EntityCollect.instance.getRenderNodes(scene3D, camera);
+        this.compute(view, occlusionSystem);
+        let op_bundleList = this.renderBundleOp(view, collectInfo, occlusionSystem);
+        let tr_bundleList = true
+            ? []
+            : this.renderBundleTr(view, collectInfo, occlusionSystem);
+        let command = GPUContext.beginCommandEncoder();
+        let encoder = GPUContext.beginRenderPass(command, this.rendererPassState);
+        if (op_bundleList.length > 0) {
+            encoder.executeBundles(op_bundleList);
+        }
+        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._rendererType)) {
+                    node.nodeUpdate(view, this._rendererType, this.rendererPassState, null);
+                    break;
+                }
+            }
+        }
+        this.drawRenderNodes(view, encoder, command, collectInfo.opaqueList, occlusionSystem);
+        if (tr_bundleList.length > 0) {
+            encoder.executeBundles(tr_bundleList);
+        }
+        GPUContext.endPass(encoder);
+        GPUContext.endCommandEncoder(command);
+        ProfilerUtil.end("DepthPass Renderer");
+    }
+    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;
+            if (renderNode.isDestroyed)
+                continue;
+            if (!renderNode.preInit(this._rendererType)) {
+                renderNode.nodeUpdate(view, this._rendererType, this.rendererPassState);
+            }
+            renderNode.renderPass2(view, this._rendererType, this.rendererPassState, clusterLightingBuffer, encoder);
+        }
+    }
+}

package/dist/src/gfx/renderJob/passRenderer/preDepth/ZCullingCompute.d.ts

@@ -0,0 +1,12 @@
+import { Scene3D } from "../../../../core/Scene3D";
+import { ComputeGPUBuffer } from "../../../graphics/webGpu/core/buffer/ComputeGPUBuffer";
+import { Texture } from "../../../graphics/webGpu/core/texture/Texture";
+import { ComputeShader } from "../../../graphics/webGpu/shader/ComputeShader";
+import { OcclusionSystem } from "../../occlusion/OcclusionSystem";
+export declare class ZCullingCompute {
+    computeShader: ComputeShader;
+    visibleBuffer: ComputeGPUBuffer;
+    texture: Texture;
+    constructor();
+    compute(scene: Scene3D, occlusionSystem: OcclusionSystem): void;
+}

package/dist/src/gfx/renderJob/passRenderer/preDepth/ZCullingCompute.js

@@ -0,0 +1,26 @@
+import { ZPassShader_cs } from "../../../../assets/shader/core/pass/ZPassShader_cs";
+import { ComputeGPUBuffer } from "../../../graphics/webGpu/core/buffer/ComputeGPUBuffer";
+import { ComputeShader } from "../../../graphics/webGpu/shader/ComputeShader";
+import { GPUContext } from "../../GPUContext";
+import { RTResourceConfig } from "../../config/RTResourceConfig";
+import { RTResourceMap } from "../../frame/RTResourceMap";
+export class ZCullingCompute {
+    constructor() {
+        this.computeShader = new ComputeShader(ZPassShader_cs);
+        this.visibleBuffer = new ComputeGPUBuffer(8192 * 2);
+        this.computeShader.setStorageBuffer(`visibleBuffer`, this.visibleBuffer);
+        this.texture = RTResourceMap.getTexture(RTResourceConfig.zBufferTexture_NAME);
+        this.computeShader.setSamplerTexture(`zBufferTexture`, this.texture);
+        this.computeShader.workerSizeX = Math.ceil(this.texture.width / 8);
+        this.computeShader.workerSizeY = Math.ceil(this.texture.height / 8);
+        this.computeShader.workerSizeZ = 1;
+    }
+    compute(scene, occlusionSystem) {
+        this.visibleBuffer.reset(true, 0);
+        this.visibleBuffer.apply();
+        let command = GPUContext.beginCommandEncoder();
+        GPUContext.computeCommand(command, [this.computeShader]);
+        this.visibleBuffer.readBuffer();
+        occlusionSystem.zVisibleList = this.visibleBuffer.outFloat32Array;
+    }
+}

package/dist/src/gfx/renderJob/passRenderer/shadow/PointLightShadowRenderer.d.ts

@@ -0,0 +1,32 @@
+import { Camera3D } from "../../../../core/Camera3D";
+import { CubeCamera } from "../../../../core/CubeCamera";
+import { VirtualTexture } from "../../../../textures/VirtualTexture";
+import { OcclusionSystem } from "../../occlusion/OcclusionSystem";
+import { RendererBase } from "../RendererBase";
+import { RenderNode } from "../../../../components/renderer/RenderNode";
+import { View3D } from "../../../../core/View3D";
+import { DepthCubeArrayTexture } from "../../../../textures/DepthCubeArrayTexture";
+import { ILight } from "../../../../components/lights/ILight";
+import { RenderContext } from "../RenderContext";
+import { ClusterLightingBuffer } from "../cluster/ClusterLightingBuffer";
+type CubeShadowMapInfo = {
+    cubeCamera: CubeCamera;
+    depthTexture: VirtualTexture[];
+    renderContext: RenderContext[];
+};
+export declare class PointLightShadowRenderer extends RendererBase {
+    shadowPassCount: number;
+    private _forceUpdate;
+    private _shadowCameraDic;
+    shadowCamera: Camera3D;
+    cubeArrayTexture: DepthCubeArrayTexture;
+    colorTexture: VirtualTexture;
+    shadowSize: number;
+    constructor();
+    getShadowCamera(view: View3D, lightBase: ILight): CubeShadowMapInfo;
+    render(view: View3D, occlusionSystem: OcclusionSystem): void;
+    private renderSceneOnce;
+    protected drawShadowRenderNodes(view: View3D, shadowCamera: Camera3D, renderContext: RenderContext, nodes: RenderNode[], occlusionSystem: OcclusionSystem): void;
+    drawNodes(view: View3D, camera: Camera3D, renderContext: RenderContext, nodes: RenderNode[], occlusionSystem: OcclusionSystem, clusterLightingBuffer: ClusterLightingBuffer): void;
+}
+export {};

package/dist/src/gfx/renderJob/passRenderer/shadow/PointLightShadowRenderer.js

@@ -0,0 +1,193 @@
+import { LightType } from "../../../../components/lights/LightData";
+import { ShadowLightsCollect } from "../../collect/ShadowLightsCollect";
+import { Engine3D } from "../../../../Engine3D";
+import { VirtualTexture } from "../../../../textures/VirtualTexture";
+import { GPUTextureFormat } from "../../../graphics/webGpu/WebGPUConst";
+import { EntityCollect } from "../../collect/EntityCollect";
+import { GPUContext } from "../../GPUContext";
+import { RTFrame } from "../../frame/RTFrame";
+import { RendererBase } from "../RendererBase";
+import { PointShadowCubeCamera } from "../../../../core/PointShadowCubeCamera";
+import { DepthCubeArrayTexture } from "../../../../textures/DepthCubeArrayTexture";
+import { Time } from "../../../../util/Time";
+import { RTDescriptor } from "../../../graphics/webGpu/descriptor/RTDescriptor";
+import { PassType } from "../state/PassType";
+import { Reference } from "../../../../util/Reference";
+import { GlobalBindGroup } from "../../../graphics/webGpu/core/bindGroups/GlobalBindGroup";
+export class PointLightShadowRenderer extends RendererBase {
+    constructor() {
+        super();
+        this._forceUpdate = false;
+        this.shadowSize = 1024;
+        this.passType = PassType.POINT_SHADOW;
+        this._shadowCameraDic = new Map();
+        this.cubeArrayTexture = new DepthCubeArrayTexture(this.shadowSize, this.shadowSize, 8);
+        this.colorTexture = new VirtualTexture(this.shadowSize, this.shadowSize, GPUTextureFormat.bgra8unorm, false);
+        Reference.getInstance().attached(this.cubeArrayTexture, this);
+    }
+    getShadowCamera(view, lightBase) {
+        let cubeShadowMapInfo;
+        if (this._shadowCameraDic.has(lightBase)) {
+            cubeShadowMapInfo = this._shadowCameraDic.get(lightBase);
+        }
+        else {
+            let camera = new PointShadowCubeCamera(view.camera.near, view.camera.far, 90, true);
+            camera.label = lightBase.name;
+            let depths = [];
+            let renderContext = [];
+            for (let i = 0; i < 6; i++) {
+                let depthTexture = new VirtualTexture(this.shadowSize, this.shadowSize, this.cubeArrayTexture.format, false);
+                let rtFrame = new RTFrame([this.colorTexture], [new RTDescriptor()]);
+                depthTexture.name =
+                    `shadowDepthTexture_` + lightBase.name + i + "_face";
+                depths[i] = depthTexture;
+                rtFrame.depthTexture = depthTexture;
+                rtFrame.label = "shadowRender";
+                rtFrame.customSize = true;
+                renderContext[i] = this.getRenderContext(rtFrame);
+            }
+            cubeShadowMapInfo = {
+                cubeCamera: camera,
+                depthTexture: depths,
+                renderContext: renderContext,
+            };
+            this._shadowCameraDic.set(lightBase, cubeShadowMapInfo);
+        }
+        return cubeShadowMapInfo;
+    }
+    render(view, occlusionSystem) {
+        if (!Engine3D.setting.shadow.enable)
+            return;
+        this.shadowPassCount = 0;
+        let camera = view.camera;
+        let scene = view.scene;
+        let shadowLight = ShadowLightsCollect.getPointShadowLightWhichScene(scene);
+        let li = 0;
+        let shadowLightCount = shadowLight.length;
+        for (let si = 0; si < shadowLightCount; si++) {
+            let light = shadowLight[si];
+            if (light.lightData.lightType == LightType.DirectionLight)
+                continue;
+            if (light.lightData.castShadowIndex > -1 &&
+                (light.needUpdateShadow ||
+                    this._forceUpdate ||
+                    Time.frame < 5 ||
+                    light.realTimeShadow)) {
+                light.needUpdateShadow = false;
+                let cubeShadowMapInfo = this.getShadowCamera(view, light);
+                let worldPos = light.transform.worldPosition;
+                cubeShadowMapInfo.cubeCamera.x = worldPos.x;
+                cubeShadowMapInfo.cubeCamera.y = worldPos.y;
+                cubeShadowMapInfo.cubeCamera.z = worldPos.z;
+                let collectInfo;
+                cubeShadowMapInfo.cubeCamera.transform.updateWorldMatrix(true);
+                {
+                    occlusionSystem.update(cubeShadowMapInfo.cubeCamera.right_camera, scene);
+                    collectInfo = EntityCollect.instance.getRenderNodes(scene, cubeShadowMapInfo.cubeCamera.right_camera);
+                    this.renderSceneOnce(0, cubeShadowMapInfo, view, cubeShadowMapInfo.cubeCamera.right_camera, collectInfo, occlusionSystem);
+                    occlusionSystem.update(cubeShadowMapInfo.cubeCamera.left_camera, scene);
+                    collectInfo = EntityCollect.instance.getRenderNodes(scene, cubeShadowMapInfo.cubeCamera.left_camera);
+                    this.renderSceneOnce(1, cubeShadowMapInfo, view, cubeShadowMapInfo.cubeCamera.left_camera, collectInfo, occlusionSystem);
+                    occlusionSystem.update(cubeShadowMapInfo.cubeCamera.up_camera, scene);
+                    collectInfo = EntityCollect.instance.getRenderNodes(scene, cubeShadowMapInfo.cubeCamera.up_camera);
+                    this.renderSceneOnce(2, cubeShadowMapInfo, view, cubeShadowMapInfo.cubeCamera.up_camera, collectInfo, occlusionSystem);
+                    occlusionSystem.update(cubeShadowMapInfo.cubeCamera.down_camera, scene);
+                    collectInfo = EntityCollect.instance.getRenderNodes(scene, cubeShadowMapInfo.cubeCamera.down_camera);
+                    this.renderSceneOnce(3, cubeShadowMapInfo, view, cubeShadowMapInfo.cubeCamera.down_camera, collectInfo, occlusionSystem);
+                    occlusionSystem.update(cubeShadowMapInfo.cubeCamera.front_camera, scene);
+                    collectInfo = EntityCollect.instance.getRenderNodes(scene, cubeShadowMapInfo.cubeCamera.front_camera);
+                    this.renderSceneOnce(4, cubeShadowMapInfo, view, cubeShadowMapInfo.cubeCamera.front_camera, collectInfo, occlusionSystem);
+                    occlusionSystem.update(cubeShadowMapInfo.cubeCamera.back_camera, scene);
+                    collectInfo = EntityCollect.instance.getRenderNodes(scene, cubeShadowMapInfo.cubeCamera.back_camera);
+                    this.renderSceneOnce(5, cubeShadowMapInfo, view, cubeShadowMapInfo.cubeCamera.back_camera, collectInfo, occlusionSystem);
+                }
+                let qCommand = GPUContext.beginCommandEncoder();
+                for (let i = 0; i < 6; i++) {
+                    qCommand.copyTextureToTexture({
+                        texture: cubeShadowMapInfo.depthTexture[i].getGPUTexture(),
+                        mipLevel: 0,
+                        origin: { x: 0, y: 0, z: 0 },
+                    }, {
+                        texture: this.cubeArrayTexture.getGPUTexture(),
+                        mipLevel: 0,
+                        origin: { x: 0, y: 0, z: light.shadowIndex * 6 + i },
+                    }, {
+                        width: this.shadowSize,
+                        height: this.shadowSize,
+                        depthOrArrayLayers: 1,
+                    });
+                }
+                GPUContext.endCommandEncoder(qCommand);
+                li++;
+            }
+        }
+        this._forceUpdate = false;
+    }
+    renderSceneOnce(face, cubeShadowMapInfo, view, shadowCamera, collectInfo, occlusionSystem) {
+        let renderContext = cubeShadowMapInfo.renderContext[face];
+        renderContext.clean();
+        renderContext.beginOpaqueRenderPass();
+        renderContext.encoder.setViewport(0, 0, this.shadowSize, this.shadowSize, 0.0, 1.0);
+        renderContext.encoder.setScissorRect(0, 0, this.shadowSize, this.shadowSize);
+        shadowCamera.onUpdate();
+        shadowCamera.transform.updateWorldMatrix(true);
+        for (const iterator of collectInfo.opaqueList) {
+            let node = iterator;
+            if (!node.isDestroyed && node.preInit(this._rendererType)) {
+                node.nodeUpdate(view, this._rendererType, renderContext.rendererPassState, null);
+                break;
+            }
+        }
+        this.drawShadowRenderNodes(view, shadowCamera, renderContext, collectInfo.opaqueList, occlusionSystem);
+        this.drawShadowRenderNodes(view, shadowCamera, renderContext, collectInfo.transparentList, occlusionSystem);
+        renderContext.endRenderPass();
+    }
+    drawShadowRenderNodes(view, shadowCamera, renderContext, nodes, occlusionSystem) {
+        GlobalBindGroup.updateCameraGroup(shadowCamera);
+        GPUContext.bindCamera(renderContext.encoder, shadowCamera);
+        this.drawNodes(view, shadowCamera, renderContext, nodes, occlusionSystem, null);
+    }
+    drawNodes(view, camera, 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, renderContext.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.castShadow)
+                    continue;
+                if (renderNode.isDestroyed)
+                    continue;
+                if (!renderNode.preInit(this._rendererType)) {
+                    renderNode.nodeUpdate(view, this._rendererType, renderContext.rendererPassState, clusterLightingBuffer);
+                }
+                for (let material of renderNode.materials) {
+                    let passes = material.getPass(this._rendererType);
+                    if (!passes || passes.length == 0)
+                        continue;
+                    for (let pass of passes) {
+                        const renderShader = pass;
+                        if (renderShader.pipeline) {
+                            renderShader.setUniformFloat("cameraFar", camera.far);
+                            renderShader.setUniformVector3("lightWorldPos", camera.transform.worldPosition);
+                            renderShader.materialDataUniformBuffer.apply();
+                        }
+                    }
+                }
+                renderNode.renderPass(view, this.passType, renderContext);
+            }
+        }
+    }
+}

package/dist/src/gfx/renderJob/passRenderer/shadow/ShadowMapPassRenderer.d.ts

@@ -0,0 +1,27 @@
+import { RenderNode } from "../../../../components/renderer/RenderNode";
+import { Camera3D } from "../../../../core/Camera3D";
+import { View3D } from "../../../../core/View3D";
+import { Depth2DTextureArray } from "../../../../textures/Depth2DTextureArray";
+import { OcclusionSystem } from "../../occlusion/OcclusionSystem";
+import { RendererPassState } from "../state/RendererPassState";
+import { RendererBase } from "../RendererBase";
+import { ClusterLightingBuffer } from "../cluster/ClusterLightingBuffer";
+export declare class ShadowMapPassRenderer extends RendererBase {
+    shadowPassCount: number;
+    depth2DArrayTexture: Depth2DTextureArray;
+    rendererPassStates: RendererPassState[];
+    private _forceUpdate;
+    constructor();
+    setShadowMap(size: number, cascades: number): void;
+    render(view: View3D, occlusionSystem: OcclusionSystem): void;
+    private copyDepthTexture;
+    private _shadowPos;
+    private _shadowCameraTarget;
+    private poseShadowCamera;
+    compute(): void;
+    private renderShadow;
+    protected renderShadowBundleOp(view: View3D, shadowCamera: Camera3D, state: RendererPassState): any[];
+    protected renderShadowBundleTr(view: View3D, shadowCamera: Camera3D, state: RendererPassState): any[];
+    protected recordShadowRenderBundleNode(view: View3D, shadowCamera: Camera3D, encoder: any, nodes: RenderNode[], clusterLightingBuffer?: ClusterLightingBuffer): void;
+    protected drawShadowRenderNodes(view: View3D, shadowCamera: Camera3D, encoder: GPURenderPassEncoder, nodes: RenderNode[], clusterLightingBuffer?: ClusterLightingBuffer): void;
+}