@woosh/meep-engine 2.33.65 → 2.33.70

package/core/geom/2d/quad-tree/QuadTreeNode.js

@@ -315,8 +315,9 @@ export class QuadTreeNode extends AABB2 {
         const x1 = this.x1;
         const y1 = this.y1;
 
-        const xm = (x0 + x1) / 2;
-        const ym = (y0 + y1) / 2;
+        // get center point
+        const xm = (x0 + x1) * 0.5;
+        const ym = (y0 + y1) * 0.5;
 
         for (; i < dataLength; i++) {
             const datum = data[i];

package/core/geom/3d/triangle/computeTriangleRayIntersection.js

@@ -25,15 +25,9 @@ export function computeTriangleRayIntersection(
     result,
     origin_x, origin_y, origin_z,
     direction_x, direction_y, direction_z,
-    ax,
-    ay,
-    az,
-    bx,
-    by,
-    bz,
-    cx,
-    cy,
-    cz
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
 ) {
 
     // edge1 = a - b

package/engine/asset/loaders/GLTFAssetLoader.js

@@ -26,7 +26,6 @@ import { traverseThreeObject } from "../../graphics/ecs/highlight/renderer/trave
 import { computeTextureHash } from "./material/computeTextureHash.js";
 import { computeTextureEquality } from "./material/computeTextureEquality.js";
 import { async_traverse_three_object } from "./async_traverse_three_object.js";
-import { deinterleaveBufferGeometry } from "../../graphics/geometry/buffered/deinterleaveBufferGeometry.js";
 
 const animationOptimizer = new AnimationOptimizer();
 const materialCache = StaticMaterialCache.Global;
@@ -294,9 +293,6 @@ export class GLTFAssetLoader extends AssetLoader {
                 mesh.geometry = geometry;
             }
 
-            mesh.geometry = deinterleaveBufferGeometry(geometry);
-
-
             if (this.__enable_texture_cache) {
                 // replace textures from cache
                 replace_material_textures_from_cache(mesh.material, texture_cache);

package/engine/ecs/fow/FogOfWarRevealerSystem.js

@@ -10,6 +10,10 @@ import { obtainTerrain } from "../terrain/util/obtainTerrain.js";
 const v2 = new Vector2();
 
 export class FogOfWarRevealerSystem extends System {
+    /**
+     *
+     * @param {number} team
+     */
     constructor(team) {
         super();
 
@@ -19,6 +23,10 @@ export class FogOfWarRevealerSystem extends System {
 
         this.data = [];
 
+        /**
+         *
+         * @type {number}
+         */
         this.team = team;
     }
 

package/engine/ecs/fow/shader/screenSpaceFogOfWarShader.js

@@ -1,4 +1,5 @@
 import { Matrix4, NormalBlending, ShaderMaterial, Vector2, Vector4 } from "three";
+import { FULL_SCREEN_QUAD_VERTEX_SHADER } from "../../../graphics/FULL_SCREEN_QUAD_VERTEX_SHADER.js";
 
 /**
  Shader for drawing fog of war as a screen-space post-process effect
@@ -6,16 +7,7 @@ import { Matrix4, NormalBlending, ShaderMaterial, Vector2, Vector4 } from "three
  */
 export function buildScreenSpaceFogOfWarShader() {
     function vertexShader() {
-        return `        
-        varying vec2 vUv;
-
-        void main() {
-
-            vUv = uv;
-                
-            gl_Position = vec4( (uv - 0.5)*2.0, 0.0, 1.0 );
-            
-        }`;
+        return FULL_SCREEN_QUAD_VERTEX_SHADER;
     }
 
     function fragmentShader() {

package/engine/ecs/grid/NormalMap2AOMap.js

@@ -5,11 +5,10 @@
 
 import { ClampToEdgeWrapping, DataTexture, RGBAFormat, UnsignedByteType, Vector2 } from 'three';
 import { Sampler2D } from '../../graphics/texture/sampler/Sampler2D.js';
-import sampler2D2Texture from '../../graphics/texture/sampler/Sampler2D2Texture.js';
 import AmbientOcclusionShader from '../../graphics/shaders/AmbientOcclusionShader.js';
-import GaussianBlurShader from '../../graphics/shaders/GaussianBlurShader.js';
 import ImageFilter from '../../graphics/filter/ImageFilter.js';
 import { sampler2DtoFloat32Texture } from "../../graphics/texture/sampler/sampler2DToFloat32Texture.js";
+import { DenoiseShader } from "../../graphics/shaders/DenoiseShader.js";
 
 function filterResult2Texture(data, width, height) {
     const result = new DataTexture();
@@ -37,6 +36,7 @@ function filterResult2Texture(data, width, height) {
  * @param {Sampler2D} heightMap
  * @param {Sampler2D} normalMap
  * @param {Vector2} resultSize
+ * @param worldSize
  * @param {number} [rayLength]
  * @returns {Sampler2D}
  */
@@ -45,13 +45,13 @@ function normalMap2OcclusionMap(
     heightMap,
     normalMap,
     resultSize,
+    worldSize = new Vector2(heightMap.width, heightMap.width),
     rayLength = 17
 ) {
     const width = resultSize.x;
     const height = resultSize.y;
-    const resolution = new Vector2(heightMap.width, heightMap.height);
     //
-    const normalTexture = sampler2D2Texture(normalMap, 255, 0.5);
+    const normalTexture = sampler2DtoFloat32Texture(normalMap);
 
     const heightTexture = sampler2DtoFloat32Texture(heightMap);
 
@@ -60,17 +60,16 @@ function normalMap2OcclusionMap(
     const shaderAO = new AmbientOcclusionShader();
     shaderAO.uniforms.heightMap.value = heightTexture;
     shaderAO.uniforms.normalMap.value = normalTexture;
-    shaderAO.uniforms.resolution.value = resolution;
+    shaderAO.uniforms.world_size.value.set(worldSize.x, worldSize.y);
     shaderAO.uniforms.rayLength.value = rayLength;
     //perform filtering
     const rawAO = ImageFilter(renderer, width, height, shaderAO);
 
-    const shaderBlur = new GaussianBlurShader();
-    shaderBlur.uniforms.resolution.value = resolution;
-    shaderBlur.uniforms.tDiffuse.value = filterResult2Texture(rawAO.array, width, height);
-    shaderBlur.uniforms.sigma.value.set(1.3, 1.3);
+    const shaderDenoise = new DenoiseShader(2);
+    shaderDenoise.uniforms.source.value = filterResult2Texture(rawAO.array, width, height);
+    shaderDenoise.uniforms.pixelOffset.value.set(1 / width, 1 / height);
 
-    const smoothAO = ImageFilter(renderer, width, height, shaderBlur);
+    const smoothAO = ImageFilter(renderer, width, height, shaderDenoise);
 
     //create the sampler
     const result = new Sampler2D(new Uint8ClampedArray(width * height), 1, width, height);
@@ -79,9 +78,7 @@ function normalMap2OcclusionMap(
     const size = width * height;
 
     for (let i = 0; i < size; i++) {
-        const i4 = i * 4;
-
-        result.data[i] = smoothAO.array[i4];
+        result.data[i] = smoothAO.array[i * 4];
     }
 
     return result;

package/engine/ecs/terrain/ecs/BuildLightTexture.js

@@ -0,0 +1,106 @@
+import normalMap2AOMap from "../../grid/NormalMap2AOMap.js";
+import heightMap2NormalMap from "../../grid/HeightMap2NormalMap.js";
+import { WebGLRendererPool } from "../../../graphics/render/RendererPool.js";
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { writeSample2DDataToDataTexture } from "../../../graphics/texture/sampler/writeSampler2DDataToDataTexture.js";
+
+/**
+ *
+ * @param {WebGLRenderer} renderer
+ * @param {Sampler2D} sampler
+ * @returns {Promise<Sampler2D>}
+ */
+function promiseSamplerNormal(renderer, sampler) {
+
+    console.time("generating normal map");
+    const normalSampler = heightMap2NormalMap(renderer, sampler);
+    console.timeEnd("generating normal map");
+
+
+    return Promise.resolve(normalSampler);
+}
+
+/**
+ *
+ * @param {WebGLRenderer} renderer
+ * @param {Promise<Sampler2D>} pSamplerNormal
+ * @param {Sampler2D} samplerHeight
+ * @param {Vector2} resolution
+ * @param {Vector2} [wordSize]
+ * @param {number} rayLength
+ * @returns {Promise<unknown>}
+ */
+function promiseSamplerAO(
+    {
+        renderer,
+        pSamplerNormal,
+        samplerHeight,
+        resolution,
+        wordSize = resolution,
+        rayLength
+    }
+) {
+    return new Promise(function (resolve, reject) {
+        Promise.all([pSamplerNormal]).then(function (values) {
+            const samplerNormal = values[0];
+            console.time("generating AO map");
+            const occlusionSampler = normalMap2AOMap(
+                renderer,
+                samplerHeight,
+                samplerNormal,
+                wordSize,
+                resolution,
+                rayLength
+            );
+            console.timeEnd("generating AO map");
+            //console.info(occlusionSampler);
+            //
+            // paintSamplerOnHTML(samplerHeight, 0, 0, 40, 3);
+            // paintSamplerOnHTML(samplerNormal, 1, 0, 128, 1);
+            // paintSamplerOnHTML(occlusionSampler, 2, 0, 1, 0);
+            //
+            //
+            resolve(occlusionSampler);
+        }, reject);
+    });
+}
+
+/**
+ *
+ * @param {THREE.DataTexture} texture
+ * @param {Vector2} [resolution]
+ * @param {Sampler2D} heightSampler
+ * @param {number} [rayLength]
+ * @param {Vector2} [worldSize]
+ * @returns {Promise}
+ */
+export function buildLightTexture({
+                                      texture,
+                                      heightSampler,
+                                      resolution= new Vector2(texture.image.width, texture.image.height),
+                                      rayLength = 11,
+                                      worldSize = resolution
+                                  }) {
+
+    const renderer = WebGLRendererPool.global.get();
+
+    const normal = promiseSamplerNormal(renderer, heightSampler);
+    const ao = promiseSamplerAO({
+        renderer: renderer,
+        pSamplerNormal: normal,
+        samplerHeight: heightSampler,
+        resolution: resolution,
+        rayLength: rayLength,
+        worldSize
+    });
+
+    const promise = ao.then(sampler => {
+        writeSample2DDataToDataTexture(sampler, texture);
+    });
+
+    Promise.all([normal, ao]).finally(() => {
+        WebGLRendererPool.global.release(renderer);
+    });
+
+    return promise;
+}

package/engine/ecs/terrain/ecs/PromiseSamplerHeight.js

@@ -0,0 +1,59 @@
+import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { deserializeTexture } from "../../../graphics/texture/sampler/TextureBinaryBufferSerializer.js";
+import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
+import { GameAssetType } from "../../../asset/GameAssetType.js";
+import rgbaData2valueSampler2D from "../../../graphics/texture/sampler/rgbaData2valueSampler2D.js";
+
+/**
+ *
+ * @param zRange
+ * @param heightMapURL
+ * @param {AssetManager} assetManager
+ * @returns {Promise<any>}
+ */
+export function promiseSamplerHeight(zRange, heightMapURL, assetManager) {
+    return new Promise(function (fulfill, reject) {
+
+        function assetObtained(asset) {
+            const array = asset.create();
+
+            const binaryBuffer = new BinaryBuffer();
+            //
+            // binaryBuffer.writeUint32(2560);
+            // binaryBuffer.writeUint32(2560);
+            //
+            // binaryBuffer.writeUint8(1);
+            //
+            // binaryBuffer.writeUint8(6);
+
+            binaryBuffer.writeBytes(new Uint8Array(array), 0, array.length);
+
+            binaryBuffer.position = 0;
+
+            const sampler2D = deserializeTexture(binaryBuffer);
+            fulfill(sampler2D);
+        }
+
+
+        if (heightMapURL === undefined) {
+            console.warn('Height map is not specified');
+            const defaultSampler = new Sampler2D(new Uint8Array(1), 1, 1, 1);
+            fulfill(defaultSampler);
+        } else if (heightMapURL.endsWith('.bin')) {
+            //load texture from a binary file
+            assetManager.get(heightMapURL, GameAssetType.ArrayBuffer, assetObtained, reject);
+        } else {
+            assetManager.get(heightMapURL, GameAssetType.Image, function (asset) {
+                const image = asset.create();
+
+                // plane
+                const imgWidth = image.width;
+                const imgHeight = image.height;
+
+                const samplerHeight = rgbaData2valueSampler2D(image.data, imgWidth, imgHeight, zRange, -zRange / 2);
+
+                fulfill(samplerHeight);
+            }, reject);
+        }
+    });
+}

package/engine/ecs/terrain/ecs/Terrain.js

@@ -14,9 +14,6 @@ import {
 } from 'three';
 import { clamp } from "../../../../core/math/clamp.js";
 import { Sampler2D } from '../../../graphics/texture/sampler/Sampler2D.js';
-import heightMap2NormalMap from '../../grid/HeightMap2NormalMap.js';
-import normalMap2AOMap from '../../grid/NormalMap2AOMap.js';
-import rgbaData2valueSampler2D from '../../../graphics/texture/sampler/rgbaData2valueSampler2D.js';
 import { BinaryNode } from '../../../../core/bvh2/BinaryNode.js';
 import Vector2 from '../../../../core/geom/Vector2.js';
 import { TerrainOverlay } from '../overlay/TerrainOverlay.js';
@@ -24,13 +21,9 @@ import { TerrainOverlay } from '../overlay/TerrainOverlay.js';
 import Clouds from '../TerrainClouds.js';
 
 import TerrainTileManager from '../tiles/TerrainTileManager.js';
-import { WebGLRendererPool } from "../../../graphics/render/RendererPool.js";
-import { deserializeTexture } from "../../../graphics/texture/sampler/TextureBinaryBufferSerializer.js";
-import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
 import { TerrainPreview } from "../TerrainPreview.js";
 import { assert } from "../../../../core/assert.js";
 import { GameAssetType } from "../../../asset/GameAssetType.js";
-import { writeSample2DDataToDataTexture } from "../../../graphics/texture/sampler/writeSampler2DDataToDataTexture.js";
 import { TerrainLayers } from "./layers/TerrainLayers.js";
 import { SplatMaterial } from "../../../graphics/material/SplatMaterial.js";
 import { loadLegacyTerrainSplats, SplatMapping } from "./splat/SplatMapping.js";
@@ -41,147 +34,8 @@ import { MeepSettings } from "../../../MeepSettings.js";
 import { loadLegacyTerrainLayers } from "./layers/loadLegacyTerrainLayers.js";
 import { TerrainFlags } from "./TerrainFlags.js";
 import { IllegalStateException } from "../../../../core/fsm/exceptions/IllegalStateException.js";
-
-/**
- *
- * @param zRange
- * @param heightMapURL
- * @param {AssetManager} assetManager
- * @returns {Promise<any>}
- */
-function promiseSamplerHeight(zRange, heightMapURL, assetManager) {
-    return new Promise(function (fulfill, reject) {
-
-        function assetObtained(asset) {
-            const array = asset.create();
-
-            const binaryBuffer = new BinaryBuffer();
-            //
-            // binaryBuffer.writeUint32(2560);
-            // binaryBuffer.writeUint32(2560);
-            //
-            // binaryBuffer.writeUint8(1);
-            //
-            // binaryBuffer.writeUint8(6);
-
-            binaryBuffer.writeBytes(new Uint8Array(array), 0, array.length);
-
-            binaryBuffer.position = 0;
-
-            const sampler2D = deserializeTexture(binaryBuffer);
-            fulfill(sampler2D);
-        }
-
-
-        if (heightMapURL === undefined) {
-            console.warn('Height map is not specified');
-            const defaultSampler = new Sampler2D(new Uint8Array(1), 1, 1, 1);
-            fulfill(defaultSampler);
-        } else if (heightMapURL.endsWith('.bin')) {
-            //load texture from a binary file
-            assetManager.get(heightMapURL, GameAssetType.ArrayBuffer, assetObtained, reject);
-        } else {
-            assetManager.get(heightMapURL, GameAssetType.Image, function (asset) {
-                const image = asset.create();
-
-                // plane
-                const imgWidth = image.width;
-                const imgHeight = image.height;
-
-                const samplerHeight = rgbaData2valueSampler2D(image.data, imgWidth, imgHeight, zRange, -zRange / 2);
-
-                fulfill(samplerHeight);
-            }, reject);
-        }
-    });
-}
-
-/**
- *
- * @param {WebGLRenderer} renderer
- * @param {Sampler2D} sampler
- * @returns {Promise<Sampler2D>}
- */
-function promiseSamplerNormal(renderer, sampler) {
-
-    console.time("generating normal map");
-    const normalSampler = heightMap2NormalMap(renderer, sampler);
-    console.timeEnd("generating normal map");
-
-
-    return Promise.resolve(normalSampler);
-}
-
-/**
- *
- * @param {WebGLRenderer} renderer
- * @param {Promise<Sampler2D>} pSamplerNormal
- * @param {Sampler2D} samplerHeight
- * @param {Vector2} resolution
- * @param {number} rayLength
- * @returns {Promise<unknown>}
- */
-function promiseSamplerAO(
-    renderer,
-    pSamplerNormal,
-    samplerHeight,
-    resolution,
-    rayLength
-) {
-    return new Promise(function (resolve, reject) {
-        Promise.all([pSamplerNormal]).then(function (values) {
-            const samplerNormal = values[0];
-            console.time("generating AO map");
-            const occlusionSampler = normalMap2AOMap(
-                renderer,
-                samplerHeight,
-                samplerNormal,
-                resolution,
-                rayLength
-            );
-            console.timeEnd("generating AO map");
-            //console.info(occlusionSampler);
-            //
-            // paintSamplerOnHTML(samplerHeight, 0, 0, 40, 3);
-            // paintSamplerOnHTML(samplerNormal, 1, 0, 128, 1);
-            // paintSamplerOnHTML(occlusionSampler, 2, 0, 1, 0);
-            //
-            //
-            resolve(occlusionSampler);
-        }, reject);
-    });
-}
-
-/**
- *
- * @param {DataTexture} texture
- * @param {Vector2} resolution
- * @param {Sampler2D} heightSampler
- * @param {number} heightRange
- * @param {number} [rayLength]
- * @returns {Promise}
- */
-function buildLightTexture({ texture, heightSampler, resolution, rayLength = 17 }) {
-
-    const renderer = WebGLRendererPool.global.get();
-
-    if (resolution === undefined) {
-        resolution = new Vector2(texture.image.width, texture.image.height);
-    }
-
-    const normal = promiseSamplerNormal(renderer, heightSampler);
-    const ao = promiseSamplerAO(renderer, normal, heightSampler, resolution, rayLength);
-
-    const promise = ao.then(sampler => {
-        writeSample2DDataToDataTexture(sampler, texture);
-    });
-
-    Promise.all([normal, ao]).finally(() => {
-        WebGLRendererPool.global.release(renderer);
-    });
-
-    return promise;
-}
+import { buildLightTexture } from "./BuildLightTexture.js";
+import { promiseSamplerHeight } from "./PromiseSamplerHeight.js";
 
 let idCounter = 0;
 
@@ -903,13 +757,13 @@ class Terrain {
         this.updateWorkerHeights();
     }
 
-    updateWorkerHeights() {
+    async updateWorkerHeights() {
         const s = this.samplerHeight;
         const worker = this.buildWorker;
 
-        worker.setHeightSampler(s.data, s.itemSize, s.width, s.height);
+        await worker.setHeightSampler(s.data, s.itemSize, s.width, s.height);
 
-       return worker.computeHeightRange()
+        return await worker.computeHeightRange()
             .then(({ min, max }) => {
                 this.tiles.setHeightRange(min, max);
             });
@@ -1012,7 +866,12 @@ class Terrain {
         this.setFlag(TerrainFlags.Built);
     }
 
-    buildLightMap() {
+    /**
+     *
+     * @param {number} quality resolution in texels per grid cell (4 = 4x4 light map texels per single grid cell)
+     * @return {Promise<DataTexture>}
+     */
+    buildLightMap(quality = 4) {
 
 
         const size_x = this.size.x;
@@ -1035,7 +894,9 @@ class Terrain {
 
         const promise = buildLightTexture({
             texture,
-            heightSampler: this.samplerHeight
+            heightSampler: this.samplerHeight,
+            worldSize: new Vector2(size_x * this.gridScale, size_y * this.gridScale),
+            resolution: new Vector2(size_x * quality, size_y *quality)
         });
 
 

package/engine/graphics/FULL_SCREEN_QUAD_VERTEX_SHADER.js

@@ -0,0 +1,10 @@
+export const FULL_SCREEN_QUAD_VERTEX_SHADER = `        
+        varying vec2 vUv;
+
+        void main() {
+
+            vUv = uv;
+                
+            gl_Position = vec4( (uv - 0.5)*2.0, 0.0, 1.0 );
+            
+        }`;

package/engine/graphics/filter/ImageFilter.js

@@ -5,13 +5,14 @@
 
 import { LinearFilter, Mesh, OrthographicCamera, Scene, ShaderMaterial, WebGLRenderTarget } from 'three';
 import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
+import { FULL_SCREEN_QUAD_VERTEX_SHADER } from "../FULL_SCREEN_QUAD_VERTEX_SHADER.js";
 
 /**
  *
  * @param {WebGLRenderer} renderer
  * @param {number} width
  * @param {number} height
- * @param {{vertexShader:string,fragmentShader:string, uniforms?:Object, defines?:Object}} processShader
+ * @param {{vertexShader?:string,fragmentShader:string, uniforms?:Object, defines?:Object}} processShader
  * @param {Uint8Array} [destination]
  * @return {{array: Uint8Array, renderer: WebGLRenderer}}
  */
@@ -34,9 +35,12 @@ function processTexture(
     scene.add(camera);
 
     //make a quad to render
-    const material = new ShaderMaterial(processShader);
+    const material = new ShaderMaterial(Object.assign({ vertexShader: FULL_SCREEN_QUAD_VERTEX_SHADER }, processShader));
+
     material.lights = false;
     material.fog = false;
+    material.uniformsNeedUpdate = true;
+    material.needsUpdate = true;
 
     const quad = new Mesh(FULL_SCREEN_TRIANGLE_GEOMETRY, material);
 

package/engine/graphics/geometry/buffered/deinterleaveBufferAttribute.js

@@ -28,9 +28,10 @@ export function deinterleaveBufferAttribute(source_attribute) {
     attribute.normalized = source_attribute.normalized;
     attribute.name = source_attribute.name;
 
+    let i = 0, j = 0;
     // copy data
-    for (let i = 0; i < item_count; i++) {
-        for (let j = 0; j < itemSize; j++) {
+    for (; i < item_count; i++) {
+        for (j = 0; j < itemSize; j++) {
             destination_array[i * itemSize + j] = source_data_array[i * stride + offset + j];
         }
     }

package/engine/graphics/geometry/buffered/query/ClippingPlaneContainmentComputingVisitor.js

@@ -79,21 +79,32 @@ export class ClippingPlaneContainmentComputingVisitor extends GeometrySpatialAcc
 
             const index3 = index * 3;
 
-            const a = this.__buffer_indices[index3] * 3;
-            const b = this.__buffer_indices[index3 + 1] * 3;
-            const c = this.__buffer_indices[index3 + 2] * 3;
+            const indices = this.__buffer_indices;
 
-            const ax = this.__buffer_vertices[a];
-            const ay = this.__buffer_vertices[a + 1];
-            const az = this.__buffer_vertices[a + 2];
+            const a = indices[index3];
+            const b = indices[index3 + 1];
+            const c = indices[index3 + 2];
 
-            const bx = this.__buffer_vertices[b];
-            const by = this.__buffer_vertices[b + 1];
-            const bz = this.__buffer_vertices[b + 2];
+            const vertices = this.__buffer_vertices;
 
-            const cx = this.__buffer_vertices[c];
-            const cy = this.__buffer_vertices[c + 1];
-            const cz = this.__buffer_vertices[c + 2];
+            const stride = this.__buffer_vertex_stride;
+            const offset = this.__buffer_position_offset;
+
+            const a_address = a * stride + offset;
+            const b_address = b * stride + offset;
+            const c_address = c * stride + offset;
+
+            const ax = vertices[a_address];
+            const ay = vertices[a_address + 1];
+            const az = vertices[a_address + 2];
+
+            const bx = vertices[b_address];
+            const by = vertices[b_address + 1];
+            const bz = vertices[b_address + 2];
+
+            const cx = vertices[c_address];
+            const cy = vertices[c_address + 1];
+            const cz = vertices[c_address + 2];
 
             for (let i = 0; i < plane_count; i++) {
                 const plane = planes[i];
@@ -108,15 +119,9 @@ export class ClippingPlaneContainmentComputingVisitor extends GeometrySpatialAcc
                     plane_normal_y,
                     plane_normal_z,
                     plane_constant,
-                    ax,
-                    ay,
-                    az,
-                    bx,
-                    by,
-                    bz,
-                    cx,
-                    cy,
-                    cz
+                    ax, ay, az,
+                    bx, by, bz,
+                    cx, cy, cz
                 );
 
                 if (side === -3) {
@@ -163,12 +168,8 @@ export class ClippingPlaneContainmentComputingVisitor extends GeometrySpatialAcc
                     plane_normal_z,
                     plane_constant,
 
-                    x0,
-                    y0,
-                    z0,
-                    x1,
-                    y1,
-                    z1
+                    x0, y0, z0,
+                    x1, y1, z1
                 );
 
                 if (side === -2) {