@onerjs/core 8.32.0 → 8.32.1

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);
         }
     }
     /**
@@ -48,20 +48,6 @@ export class LightingVolume {
         this._tesselation = n;
         this._createGeometry();
     }
-    /**
-     * Indicates whether to build the full volume (true) or only the far plane (false). Default is false.
-     */
-    get buildFullVolume() {
-        return this._buildFullVolume;
-    }
-    set buildFullVolume(value) {
-        if (this._buildFullVolume === value) {
-            return;
-        }
-        this._buildFullVolume = value;
-        this._createGeometry();
-        this._createComputeShader();
-    }
     /**
      * The mesh used as a support for the lighting volume.
      * Note that this mesh is not automatically added to the scene's mesh array.
@@ -99,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.
@@ -107,12 +104,14 @@ export class LightingVolume {
      * @param tesselation The tesselation level of the lighting volume (default: 64).
      */
     constructor(name, scene, shadowGenerator, tesselation = 64) {
+        this._buildFullVolume = true;
         this._readPixelPromise = null;
         this._readPixelAbortController = null;
         this._numFrames = 0;
         this._firstUpdate = true;
+        this._currentLightDirection = new Vector3();
+        this._needFullUpdateUBO = true;
         this._tesselation = 0;
-        this._buildFullVolume = false;
         this._frequency = 1;
         const light = shadowGenerator ? shadowGenerator.getLight() : undefined;
         if (light && !(light instanceof DirectionalLight)) {
@@ -121,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);
@@ -128,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();
         }
@@ -150,6 +153,9 @@ export class LightingVolume {
         if (this._cs) {
             isReady = this._cs.isReady() && isReady;
         }
+        if (this._cs2) {
+            isReady = this._cs2.isReady() && isReady;
+        }
         return isReady;
     }
     /**
@@ -164,15 +170,24 @@ export class LightingVolume {
             return;
         }
         this._numFrames = 0;
-        if (this._cs && this._uBuffer) {
+        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);
-            const viewProjMatrix = this._shadowGenerator.getTransformMatrix();
-            viewProjMatrix.invertToRef(InvViewProjMatrix);
-            this._uBuffer.updateMatrix("invViewProjMatrix", InvViewProjMatrix);
-            this._uBuffer.update();
-            this._engine._debugPushGroup?.(`Generate lighting volume (${this._name})`);
+            this._engine._debugPushGroup?.(`Update vertices of far plane`, 1);
             this._cs.dispatch(dispatchSize, dispatchSize, 1);
-            this._engine._debugPopGroup?.();
+            this._engine._debugPopGroup?.(1);
+            this._engine._debugPopGroup?.(1);
             this._firstUpdate = false;
         }
         else {
@@ -200,26 +215,45 @@ export class LightingVolume {
         this._uBuffer?.dispose();
         this._depthCopy?.dispose();
     }
+    _needUpdateGeometry() {
+        if (this._cs?.triggerContextRebuild || (this._light && !this._currentLightDirection.equals(this._light.direction))) {
+            this._currentLightDirection.copyFrom(this._light.direction);
+            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() {
@@ -280,13 +314,22 @@ export class LightingVolume {
         const invViewProjMatrix = shadowGenerator.getTransformMatrix().clone();
         invViewProjMatrix.invertToRef(invViewProjMatrix);
         const factor = 4;
+        if (this._needUpdateGeometry()) {
+            this._updateGeometry();
+        }
         let posIndex = startPos;
         let stepY = 0;
         for (let y = 0; y < numTesselation + 1; ++y) {
             for (let x = 0; x < numTesselation + 1; ++x) {
                 let depth = depthValues[Math.floor(mapSize * Math.floor(stepY) + x * step) * factor];
-                if (!this._buildFullVolume && (depth === 1 || y === 0 || x === 0 || y === numTesselation || x === numTesselation)) {
-                    depth = 0;
+                if (!this._buildFullVolume) {
+                    if (y === 0 || x === 0 || y === numTesselation || x === numTesselation) {
+                        posIndex += 3;
+                        continue;
+                    }
+                    if (depth === 1) {
+                        depth = 0;
+                    }
                 }
                 TmpVec3.set((x - halfTesselation) / halfTesselation, (y - halfTesselation) / halfTesselation, -1 + 2 * depth);
                 Vector3.TransformCoordinatesToRef(TmpVec3, invViewProjMatrix, TmpVec3);
@@ -301,126 +344,193 @@ export class LightingVolume {
         this._readPixelPromise = null;
         this._firstUpdate = false;
     }
+    _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() {
-        if (!this._light) {
+        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 = 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));
                 }
             }
-            const n0 = 0;
-            const n1 = positions.length / 3 - 1;
-            const n2 = n1 + 1;
-            startIndices = positions.length / 3;
+            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);
                 }
             }
-            const n3 = positions.length / 3 - 1;
-            startIndices = positions.length / 3;
+            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 = 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
-            indices.push(n0, n2, n1);
-            indices.push(n2, n3, n1);
+            for (let i = 0; i < numTesselation; ++i) {
+                this._indices.push(leftFaceStartIndex + i, leftFaceStartIndex + i + 1, topFaceStartIndex + numTesselation - i);
+                if (i < numTesselation - 1) {
+                    this._indices.push(leftFaceStartIndex + i + 1, topFaceStartIndex + numTesselation - i - 1, topFaceStartIndex + numTesselation - i);
+                }
+            }
+            for (let i = 0; i < numTesselation; ++i) {
+                this._indices.push(bottomFaceStartIndex + i, rightFaceStartIndex + numTesselation - i, rightFaceStartIndex + numTesselation - i - 1);
+                if (i < numTesselation - 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);
+            this._indices.push(0, 2, 1);
+            this._indices.push(2, 3, 1);
         }
         // Tesselate the far plane
-        let y = min.y;
         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");
-            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