@babylonjs/core 8.40.0 → 8.40.1

package/Lights/lightingVolume.d.ts

@@ -13,6 +13,7 @@ export declare class LightingVolume {
     private readonly _buildFullVolume;
     private _name;
     private _cs?;
+    private _cs2?;
     private _light?;
     private _fallbackTexture?;
     private _storageBuffer?;
@@ -22,6 +23,9 @@ export declare class LightingVolume {
     private _numFrames;
     private _firstUpdate;
     private _currentLightDirection;
+    private _positions;
+    private _indices;
+    private _needFullUpdateUBO;
     private _shadowGenerator?;
     /**
      * The shadow generator used to create the lighting volume.
@@ -56,6 +60,8 @@ export declare class LightingVolume {
      * If true, the volume has not yet been updated for the first time.
      */
     get firstUpdate(): boolean;
+    /** @internal */
+    _setComputeShaderFastMode(enabled: boolean): void;
     /**
      * Creates a new LightingVolume.
      * @param name The name of the lighting volume.
@@ -78,9 +84,12 @@ export declare class LightingVolume {
      * Disposes the lighting volume and associated resources.
      */
     dispose(): void;
-    private _recreateGeometry;
+    private _needUpdateGeometry;
     private _createComputeShader;
     private _createFallbackTextures;
     private _fallbackReadPixelAsync;
+    private _fullUpdateUBO;
     private _createGeometry;
+    private _updateGeometry;
+    private _createIndices;
 }

package/Lights/lightingVolume.js

@@ -1,6 +1,6 @@
 import { AbortError } from "../Misc/error.js";
 
-import { Matrix, Vector3 } from "../Maths/math.vector.js";
+import { Matrix, Vector3, TmpVectors } from "../Maths/math.vector.js";
 import { DirectionalLight } from "./directionalLight.js";
 import { Mesh } from "../Meshes/mesh.js";
 import { ComputeShader } from "../Compute/computeShader.js";
@@ -10,7 +10,6 @@ import { StorageBuffer } from "../Buffers/storageBuffer.js";
 import { BaseTexture } from "../Materials/Textures/baseTexture.js";
 import { VertexBuffer } from "../Buffers/buffer.js";
 import "../ShadersWGSL/lightingVolume.compute.js";
-const InvViewProjMatrix = new Matrix();
 const TmpVec3 = new Vector3();
 /**
  * Class used to create a lighting volume from a directional light's shadow generator.
@@ -29,13 +28,14 @@ export class LightingVolume {
         }
         this._shadowGenerator = sg;
         this._light = light;
-        this._createGeometry();
+        this._updateGeometry();
         if (!this._engine.isWebGPU) {
             this._createFallbackTextures();
         }
         const depthTexture = this._shadowGenerator.getShadowMap()?.depthStencilTexture;
-        if (this._cs && depthTexture) {
+        if (this._engine.isWebGPU && depthTexture) {
             this._cs.setInternalTexture("shadowMap", depthTexture);
+            this._cs2.setInternalTexture("shadowMap", depthTexture);
         }
     }
     /**
@@ -46,7 +46,7 @@ export class LightingVolume {
     }
     set tesselation(n) {
         this._tesselation = n;
-        this._createGeometry(true);
+        this._createGeometry();
     }
     /**
      * The mesh used as a support for the lighting volume.
@@ -85,6 +85,17 @@ export class LightingVolume {
     get firstUpdate() {
         return this._firstUpdate;
     }
+    /** @internal */
+    _setComputeShaderFastMode(enabled) {
+        if (this._cs) {
+            this._cs.fastMode = enabled;
+            this._cs.triggerContextRebuild = enabled;
+        }
+        if (this._cs2) {
+            this._cs2.fastMode = enabled;
+            this._cs2.triggerContextRebuild = enabled;
+        }
+    }
     /**
      * Creates a new LightingVolume.
      * @param name The name of the lighting volume.
@@ -99,6 +110,7 @@ export class LightingVolume {
         this._numFrames = 0;
         this._firstUpdate = true;
         this._currentLightDirection = new Vector3();
+        this._needFullUpdateUBO = true;
         this._tesselation = 0;
         this._frequency = 1;
         const light = shadowGenerator ? shadowGenerator.getLight() : undefined;
@@ -108,6 +120,7 @@ export class LightingVolume {
         this._name = name;
         this._shadowGenerator = shadowGenerator;
         this._light = light;
+        this._indices = [];
         this._engine = scene.getEngine();
         this._scene = scene;
         this._mesh = new Mesh(name, this._scene);
@@ -115,9 +128,12 @@ export class LightingVolume {
         if (this._engine.isWebGPU) {
             this._uBuffer = new UniformBuffer(this._engine);
             this._uBuffer.addUniform("invViewProjMatrix", 16);
+            this._uBuffer.addUniform("invViewMatrix", 16);
             this._uBuffer.addUniform("startVertexIndex", 1);
             this._uBuffer.addUniform("step", 1);
             this._uBuffer.addUniform("tesselation", 1);
+            this._uBuffer.addUniform("orthoMin", 3);
+            this._uBuffer.addUniform("orthoMax", 3);
             this._uBuffer.update();
             this._createComputeShader();
         }
@@ -126,7 +142,7 @@ export class LightingVolume {
             this._createFallbackTextures();
         }
         this._tesselation = tesselation;
-        this._createGeometry(true);
+        this._createGeometry();
     }
     /**
      * Checks if the lighting volume is ready to be updated.
@@ -137,6 +153,9 @@ export class LightingVolume {
         if (this._cs) {
             isReady = this._cs.isReady() && isReady;
         }
+        if (this._cs2) {
+            isReady = this._cs2.isReady() && isReady;
+        }
         return isReady;
     }
     /**
@@ -151,16 +170,24 @@ export class LightingVolume {
             return;
         }
         this._numFrames = 0;
-        if (this._cs && this._uBuffer) {
-            this._recreateGeometry();
-            const dispatchSize = Math.ceil((this._tesselation + 1) / 8);
-            const viewProjMatrix = this._shadowGenerator.getTransformMatrix();
-            viewProjMatrix.invertToRef(InvViewProjMatrix);
-            this._uBuffer.updateMatrix("invViewProjMatrix", InvViewProjMatrix);
-            this._uBuffer.update();
+        if (this._engine.isWebGPU) {
+            this._uBuffer.updateMatrix("invViewProjMatrix", this._shadowGenerator.getTransformMatrix().invertToRef(TmpVectors.Matrix[0]));
             this._engine._debugPushGroup?.(`Update lighting volume (${this._name})`, 1);
+            if (this._needUpdateGeometry()) {
+                this._fullUpdateUBO(true);
+                const dispatchSize = Math.ceil((this._tesselation + 1) / 32);
+                this._engine._debugPushGroup?.(`Update vertices of other planes`, 1);
+                this._cs2.dispatch(dispatchSize, 1, 1);
+                this._engine._debugPopGroup?.(1);
+            }
+            else {
+                this._fullUpdateUBO();
+            }
+            const dispatchSize = Math.ceil((this._tesselation + 1) / 8);
+            this._engine._debugPushGroup?.(`Update vertices of far plane`, 1);
             this._cs.dispatch(dispatchSize, dispatchSize, 1);
             this._engine._debugPopGroup?.(1);
+            this._engine._debugPopGroup?.(1);
             this._firstUpdate = false;
         }
         else {
@@ -188,32 +215,45 @@ export class LightingVolume {
         this._uBuffer?.dispose();
         this._depthCopy?.dispose();
     }
-    _recreateGeometry() {
-        if (this._light && !this._currentLightDirection.equals(this._light.direction)) {
+    _needUpdateGeometry() {
+        if (this._cs?.triggerContextRebuild || (this._light && !this._currentLightDirection.equals(this._light.direction))) {
             this._currentLightDirection.copyFrom(this._light.direction);
-            this._createGeometry();
+            return true;
         }
+        return false;
     }
     _createComputeShader() {
-        this._cs = new ComputeShader("createLightVolume", this._engine, "lightingVolume", {
+        this._cs = new ComputeShader("updateFarPlaneVertices", this._engine, "lightingVolume", {
             bindingsMapping: {
                 shadowMap: { group: 0, binding: 0 },
                 params: { group: 0, binding: 1 },
                 positions: { group: 0, binding: 2 },
             },
             defines: !this._buildFullVolume ? ["#define KEEP_EDGES", "#define MOVE_FAR_DEPTH_TO_NEAR"] : undefined,
+            entryPoint: "updateFarPlaneVertices",
+        });
+        this._cs2 = new ComputeShader("updatePlaneVertices", this._engine, "lightingVolume", {
+            bindingsMapping: {
+                shadowMap: { group: 0, binding: 0 },
+                params: { group: 0, binding: 1 },
+                positions: { group: 0, binding: 2 },
+            },
+            entryPoint: "updatePlaneVertices",
         });
         if (this._shadowGenerator) {
             const depthTexture = this._shadowGenerator.getShadowMap()?.depthStencilTexture;
             if (depthTexture) {
                 this._cs.setInternalTexture("shadowMap", depthTexture);
+                this._cs2.setInternalTexture("shadowMap", depthTexture);
             }
         }
         if (this._uBuffer) {
             this._cs.setUniformBuffer("params", this._uBuffer);
+            this._cs2.setUniformBuffer("params", this._uBuffer);
         }
         if (this._storageBuffer) {
             this._cs.setStorageBuffer("positions", this._storageBuffer);
+            this._cs2.setStorageBuffer("positions", this._storageBuffer);
         }
     }
     _createFallbackTextures() {
@@ -274,7 +314,9 @@ export class LightingVolume {
         const invViewProjMatrix = shadowGenerator.getTransformMatrix().clone();
         invViewProjMatrix.invertToRef(invViewProjMatrix);
         const factor = 4;
-        this._recreateGeometry();
+        if (this._needUpdateGeometry()) {
+            this._updateGeometry();
+        }
         let posIndex = startPos;
         let stepY = 0;
         for (let y = 0; y < numTesselation + 1; ++y) {
@@ -302,136 +344,193 @@ export class LightingVolume {
         this._readPixelPromise = null;
         this._firstUpdate = false;
     }
-    _createGeometry(_recreateAll = false) {
-        if (!this._light) {
+    _fullUpdateUBO(force = false) {
+        const light = this._light;
+        if ((!force && !this._needFullUpdateUBO) || !light || !this._shadowGenerator) {
+            this._uBuffer.update();
+            return;
+        }
+        this._needFullUpdateUBO = false;
+        const numTesselation = this._tesselation;
+        const min = TmpVectors.Vector3[0].set(light.orthoLeft, light.orthoBottom, light.shadowMinZ ?? 0);
+        const max = TmpVectors.Vector3[1].set(light.orthoRight, light.orthoTop, light.shadowMaxZ ?? 10000);
+        const invViewMatrix = this._shadowGenerator.viewMatrix.invertToRef(TmpVectors.Matrix[1]);
+        this._uBuffer.updateUInt("startVertexIndex", this._buildFullVolume ? (numTesselation + 1) * 4 * 3 : 4 * 3);
+        this._uBuffer.updateFloat("step", ((this._shadowGenerator?.mapSize ?? 128) - 1) / numTesselation);
+        this._uBuffer.updateUInt("tesselation", numTesselation);
+        this._uBuffer.updateVector3("orthoMin", min);
+        this._uBuffer.updateVector3("orthoMax", max);
+        this._uBuffer.updateMatrix("invViewMatrix", invViewMatrix);
+        this._uBuffer.update();
+    }
+    _createGeometry() {
+        const light = this._light;
+        if (!light) {
             return;
         }
         this._tesselation = Math.max(Math.ceil(this._tesselation) & ~1, 2);
+        const numTesselation = this._tesselation;
+        const vertexNumber = (numTesselation + 1) * (numTesselation + 1) + (this._buildFullVolume ? (numTesselation + 1) * 4 : 4);
+        this._positions = new Float32Array(vertexNumber * 3);
+        this._indices.length = 0;
+        this._createIndices(light);
+        this._mesh.setIndices(this._indices, vertexNumber);
+        if (this._engine.isWebGPU) {
+            const webGPUEngine = this._engine;
+            this._storageBuffer?.dispose();
+            this._storageBuffer = new StorageBuffer(webGPUEngine, vertexNumber * 3 * 4, 8 | 3);
+            this._mesh.setVerticesBuffer(new VertexBuffer(webGPUEngine, this._storageBuffer.getBuffer(), "position", { takeBufferOwnership: false }), true, vertexNumber);
+            this._cs.setStorageBuffer("positions", this._storageBuffer);
+            this._cs2.setStorageBuffer("positions", this._storageBuffer);
+            this._cs.triggerContextRebuild = true;
+            this._cs2.triggerContextRebuild = true;
+            this._needFullUpdateUBO = true;
+        }
+        this._updateGeometry();
+    }
+    _updateGeometry() {
         const light = this._light;
-        const min = new Vector3(light.orthoLeft, light.orthoBottom, light.shadowMinZ ?? 0);
-        const max = new Vector3(light.orthoRight, light.orthoTop, light.shadowMaxZ ?? 10000);
-        const invViewMatrix = Matrix.LookAtLH(light.position, light.position.add(light.direction), Vector3.UpReadOnly);
-        invViewMatrix.invertToRef(invViewMatrix);
-        const positions = [];
-        const indices = [];
+        if (!light || !this._shadowGenerator) {
+            return;
+        }
+        if (this._indices.length === 0) {
+            this._createGeometry();
+            return;
+        }
+        if (this._engine.isWebGPU) {
+            return;
+        }
         const numTesselation = this._tesselation;
+        const min = TmpVectors.Vector3[0].set(light.orthoLeft, light.orthoBottom, light.shadowMinZ ?? 0);
+        const max = TmpVectors.Vector3[1].set(light.orthoRight, light.orthoTop, light.shadowMaxZ ?? 10000);
+        const invViewMatrix = this._shadowGenerator.viewMatrix.invertToRef(TmpVectors.Matrix[1]);
         const stepX = (max.x - min.x) / numTesselation;
         const stepY = (max.y - min.y) / numTesselation;
-        const v = new Vector3();
+        let vIndex = 0;
+        if (this._buildFullVolume) {
+            // Right faces of the frustum
+            for (let i = 0; i <= numTesselation; ++i) {
+                TmpVec3.set(max.x, min.y + i * stepY, min.z);
+                Vector3.TransformCoordinatesToRef(TmpVec3, invViewMatrix, TmpVec3);
+                this._positions[vIndex++] = TmpVec3.x;
+                this._positions[vIndex++] = TmpVec3.y;
+                this._positions[vIndex++] = TmpVec3.z;
+            }
+            // Left faces of the frustum
+            for (let i = 0; i <= numTesselation; ++i) {
+                TmpVec3.set(min.x, min.y + i * stepY, min.z);
+                Vector3.TransformCoordinatesToRef(TmpVec3, invViewMatrix, TmpVec3);
+                this._positions[vIndex++] = TmpVec3.x;
+                this._positions[vIndex++] = TmpVec3.y;
+                this._positions[vIndex++] = TmpVec3.z;
+            }
+            // Bottom faces of the frustum
+            for (let i = 0; i <= numTesselation; ++i) {
+                TmpVec3.set(min.x + i * stepX, min.y, min.z);
+                Vector3.TransformCoordinatesToRef(TmpVec3, invViewMatrix, TmpVec3);
+                this._positions[vIndex++] = TmpVec3.x;
+                this._positions[vIndex++] = TmpVec3.y;
+                this._positions[vIndex++] = TmpVec3.z;
+            }
+            // Top faces of the frustum
+            for (let i = 0; i <= numTesselation; ++i) {
+                TmpVec3.set(min.x + i * stepX, max.y, min.z);
+                Vector3.TransformCoordinatesToRef(TmpVec3, invViewMatrix, TmpVec3);
+                this._positions[vIndex++] = TmpVec3.x;
+                this._positions[vIndex++] = TmpVec3.y;
+                this._positions[vIndex++] = TmpVec3.z;
+            }
+        }
+        else {
+            // Closes the volume with two near triangles
+            TmpVec3.set(max.x, min.y, min.z);
+            Vector3.TransformCoordinatesToRef(TmpVec3, invViewMatrix, TmpVec3);
+            this._positions[vIndex++] = TmpVec3.x;
+            this._positions[vIndex++] = TmpVec3.y;
+            this._positions[vIndex++] = TmpVec3.z;
+            TmpVec3.set(max.x, max.y, min.z);
+            Vector3.TransformCoordinatesToRef(TmpVec3, invViewMatrix, TmpVec3);
+            this._positions[vIndex++] = TmpVec3.x;
+            this._positions[vIndex++] = TmpVec3.y;
+            this._positions[vIndex++] = TmpVec3.z;
+            TmpVec3.set(min.x, min.y, min.z);
+            Vector3.TransformCoordinatesToRef(TmpVec3, invViewMatrix, TmpVec3);
+            this._positions[vIndex++] = TmpVec3.x;
+            this._positions[vIndex++] = TmpVec3.y;
+            this._positions[vIndex++] = TmpVec3.z;
+            TmpVec3.set(min.x, max.y, min.z);
+            Vector3.TransformCoordinatesToRef(TmpVec3, invViewMatrix, TmpVec3);
+            this._positions[vIndex++] = TmpVec3.x;
+            this._positions[vIndex++] = TmpVec3.y;
+            this._positions[vIndex++] = TmpVec3.z;
+        }
+        this._mesh.setVerticesData("position", this._positions);
+    }
+    _createIndices(light) {
+        const invViewMatrix = Matrix.LookAtLH(light.position, light.position.add(light.direction), Vector3.UpReadOnly);
+        invViewMatrix.invertToRef(invViewMatrix);
+        const numTesselation = this._tesselation;
         const startFarIndices = this._buildFullVolume ? (numTesselation + 1) * 4 : 4;
         if (this._buildFullVolume) {
-            let startIndices = 0;
-            const rightFaceStartIndex = startIndices;
+            const rightFaceStartIndex = 0;
             // Right faces of the frustum
             for (let i = 0; i <= numTesselation; ++i) {
-                v.set(max.x, min.y + i * stepY, min.z);
-                const p = Vector3.TransformCoordinates(v, invViewMatrix);
-                positions.push(p.x, p.y, p.z);
                 if (i < numTesselation) {
-                    indices.push(startIndices + i, startFarIndices + numTesselation + (i + 1) * (numTesselation + 1), startFarIndices + numTesselation + i * (numTesselation + 1));
-                    indices.push(startIndices + i, startIndices + i + 1, startFarIndices + numTesselation + (i + 1) * (numTesselation + 1));
+                    this._indices.push(rightFaceStartIndex + i, startFarIndices + numTesselation + (i + 1) * (numTesselation + 1), startFarIndices + numTesselation + i * (numTesselation + 1));
+                    this._indices.push(rightFaceStartIndex + i, rightFaceStartIndex + i + 1, startFarIndices + numTesselation + (i + 1) * (numTesselation + 1));
                 }
             }
-            startIndices = positions.length / 3;
-            const leftFaceStartIndex = startIndices;
+            const leftFaceStartIndex = rightFaceStartIndex + numTesselation + 1;
             // Left faces of the frustum
             for (let i = 0; i <= numTesselation; ++i) {
-                v.set(min.x, min.y + i * stepY, min.z);
-                const p = Vector3.TransformCoordinates(v, invViewMatrix);
-                positions.push(p.x, p.y, p.z);
                 if (i < numTesselation) {
-                    indices.push(startIndices + i, startFarIndices + 0 + i * (numTesselation + 1), startFarIndices + 0 + (i + 1) * (numTesselation + 1));
-                    indices.push(startIndices + i, startFarIndices + 0 + (i + 1) * (numTesselation + 1), startIndices + i + 1);
+                    this._indices.push(leftFaceStartIndex + i, startFarIndices + 0 + i * (numTesselation + 1), startFarIndices + 0 + (i + 1) * (numTesselation + 1));
+                    this._indices.push(leftFaceStartIndex + i, startFarIndices + 0 + (i + 1) * (numTesselation + 1), leftFaceStartIndex + i + 1);
                 }
             }
-            startIndices = positions.length / 3;
-            const bottomFaceStartIndex = startIndices;
+            const bottomFaceStartIndex = leftFaceStartIndex + numTesselation + 1;
             // Bottom faces of the frustum
             for (let i = 0; i <= numTesselation; ++i) {
-                v.set(min.x + i * stepX, min.y, min.z);
-                const p = Vector3.TransformCoordinates(v, invViewMatrix);
-                positions.push(p.x, p.y, p.z);
                 if (i < numTesselation) {
-                    indices.push(startIndices + i, startIndices + i + 1, startFarIndices + i + 0 * (numTesselation + 1));
-                    indices.push(startIndices + i + 1, startFarIndices + i + 1 + 0 * (numTesselation + 1), startFarIndices + i + 0 * (numTesselation + 1));
+                    this._indices.push(bottomFaceStartIndex + i, bottomFaceStartIndex + i + 1, startFarIndices + i + 0 * (numTesselation + 1));
+                    this._indices.push(bottomFaceStartIndex + i + 1, startFarIndices + i + 1 + 0 * (numTesselation + 1), startFarIndices + i + 0 * (numTesselation + 1));
                 }
             }
-            startIndices = positions.length / 3;
-            const topFaceStartIndex = startIndices;
+            const topFaceStartIndex = bottomFaceStartIndex + numTesselation + 1;
             // Top faces of the frustum
             for (let i = 0; i <= numTesselation; ++i) {
-                v.set(min.x + i * stepX, max.y, min.z);
-                const p = Vector3.TransformCoordinates(v, invViewMatrix);
-                positions.push(p.x, p.y, p.z);
                 if (i < numTesselation) {
-                    indices.push(startIndices + i, startFarIndices + i + numTesselation * (numTesselation + 1), startIndices + i + 1);
-                    indices.push(startIndices + i + 1, startFarIndices + i + numTesselation * (numTesselation + 1), startFarIndices + i + 1 + numTesselation * (numTesselation + 1));
+                    this._indices.push(topFaceStartIndex + i, startFarIndices + i + numTesselation * (numTesselation + 1), topFaceStartIndex + i + 1);
+                    this._indices.push(topFaceStartIndex + i + 1, startFarIndices + i + numTesselation * (numTesselation + 1), startFarIndices + i + 1 + numTesselation * (numTesselation + 1));
                 }
             }
-            startIndices = positions.length / 3;
             // Near faces of the frustum
             for (let i = 0; i < numTesselation; ++i) {
-                indices.push(leftFaceStartIndex + i, leftFaceStartIndex + i + 1, topFaceStartIndex + numTesselation - i);
+                this._indices.push(leftFaceStartIndex + i, leftFaceStartIndex + i + 1, topFaceStartIndex + numTesselation - i);
                 if (i < numTesselation - 1) {
-                    indices.push(leftFaceStartIndex + i + 1, topFaceStartIndex + numTesselation - i - 1, topFaceStartIndex + numTesselation - i);
+                    this._indices.push(leftFaceStartIndex + i + 1, topFaceStartIndex + numTesselation - i - 1, topFaceStartIndex + numTesselation - i);
                 }
             }
             for (let i = 0; i < numTesselation; ++i) {
-                indices.push(bottomFaceStartIndex + i, rightFaceStartIndex + numTesselation - i, rightFaceStartIndex + numTesselation - i - 1);
+                this._indices.push(bottomFaceStartIndex + i, rightFaceStartIndex + numTesselation - i, rightFaceStartIndex + numTesselation - i - 1);
                 if (i < numTesselation - 1) {
-                    indices.push(bottomFaceStartIndex + i, rightFaceStartIndex + numTesselation - i - 1, bottomFaceStartIndex + i + 1);
+                    this._indices.push(bottomFaceStartIndex + i, rightFaceStartIndex + numTesselation - i - 1, bottomFaceStartIndex + i + 1);
                 }
             }
         }
         else {
-            let p;
-            v.set(max.x, min.y, min.z);
-            p = Vector3.TransformCoordinates(v, invViewMatrix);
-            positions.push(p.x, p.y, p.z);
-            v.set(max.x, max.y, min.z);
-            p = Vector3.TransformCoordinates(v, invViewMatrix);
-            positions.push(p.x, p.y, p.z);
-            v.set(min.x, min.y, min.z);
-            p = Vector3.TransformCoordinates(v, invViewMatrix);
-            positions.push(p.x, p.y, p.z);
-            v.set(min.x, max.y, min.z);
-            p = Vector3.TransformCoordinates(v, invViewMatrix);
-            positions.push(p.x, p.y, p.z);
-            indices.push(0, 2, 1);
-            indices.push(2, 3, 1);
-        }
-        // Tesselate the near plane
-        let y = min.y;
+            this._indices.push(0, 2, 1);
+            this._indices.push(2, 3, 1);
+        }
+        // Tesselate the far plane
         for (let iy = 0; iy <= numTesselation; ++iy) {
-            let x = min.x;
             for (let ix = 0; ix <= numTesselation; ++ix) {
-                v.set(x, y, min.z);
-                const p = Vector3.TransformCoordinates(v, invViewMatrix);
-                positions.push(p.x, p.y, p.z);
                 if (ix < numTesselation && iy < numTesselation) {
-                    indices.push(startFarIndices + ix + iy * (numTesselation + 1), startFarIndices + ix + 1 + iy * (numTesselation + 1), startFarIndices + ix + 1 + (iy + 1) * (numTesselation + 1));
-                    indices.push(startFarIndices + ix + iy * (numTesselation + 1), startFarIndices + ix + 1 + (iy + 1) * (numTesselation + 1), startFarIndices + ix + (iy + 1) * (numTesselation + 1));
+                    this._indices.push(startFarIndices + ix + iy * (numTesselation + 1), startFarIndices + ix + 1 + iy * (numTesselation + 1), startFarIndices + ix + 1 + (iy + 1) * (numTesselation + 1));
+                    this._indices.push(startFarIndices + ix + iy * (numTesselation + 1), startFarIndices + ix + 1 + (iy + 1) * (numTesselation + 1), startFarIndices + ix + (iy + 1) * (numTesselation + 1));
                 }
-                x += stepX;
             }
-            y += stepY;
-        }
-        if (this._uBuffer && this._cs) {
-            const webGPUEngine = this._engine;
-            this._storageBuffer?.dispose();
-            this._storageBuffer = new StorageBuffer(webGPUEngine, positions.length * 4, 8 | 3);
-            this._storageBuffer.update(positions);
-            const vertexBuffer = new VertexBuffer(webGPUEngine, this._storageBuffer.getBuffer(), "position", { takeBufferOwnership: false });
-            this._mesh.setVerticesBuffer(vertexBuffer);
-            this._cs.setStorageBuffer("positions", this._storageBuffer);
-            this._uBuffer.updateUInt("startVertexIndex", this._buildFullVolume ? (numTesselation + 1) * 4 * 3 : 4 * 3);
-            this._uBuffer.updateFloat("step", ((this._shadowGenerator?.mapSize ?? 128) - 1) / numTesselation);
-            this._uBuffer.updateUInt("tesselation", numTesselation);
-        }
-        else {
-            this._mesh.setVerticesData("position", positions);
         }
-        this._mesh.setIndices(indices, positions.length / 3);
     }
 }
 //# sourceMappingURL=lightingVolume.js.map