@woosh/meep-engine 2.39.37 → 2.39.38

package/engine/asset/loaders/ArrayBufferLoader.js

@@ -4,20 +4,84 @@ import { CrossOriginKind } from "../CORS/CrossOriginKind.js";
 
 export class ArrayBufferLoader extends AssetLoader {
     load(path, success, failure, progress) {
+        const coc = this.assetManager.crossOriginConfig;
 
-        const xhr = new XMLHttpRequest();
-        xhr.open('GET', path, true);
-        xhr.responseType = "arraybuffer";
+        const headers = new Headers();
 
-        const coc = this.assetManager.crossOriginConfig;
+        const request = new Request(path, {
+            credentials: coc.kind === CrossOriginKind.UseCredentials ? 'include' : 'same-origin',
+            headers: headers
+        });
+
+        fetch(request)
+            .then(response => {
+                if (response.status === 200 || response.status === 0) {
+
+                    // Some browsers return HTTP Status 0 when using non-http protocol
+                    // e.g. 'file://' or 'data://'. Handle as success.
+
+                    if (response.status === 0) {
+
+                        console.warn('HTTP Status 0 received.');
+
+                    }
+
+                    if (typeof ReadableStream === 'undefined' || response.body.getReader === undefined) {
+
+                        return response;
+
+                    }
+
+                    const reader = response.body.getReader();
+                    const contentLength = response.headers.get('Content-Length');
+                    const total = contentLength ? parseInt(contentLength) : 0;
+                    const lengthComputable = total !== 0;
+                    let loaded = 0;
+
+                    // periodically read data into the new stream tracking while download progress
+                    const stream = new ReadableStream({
+                        start(controller) {
+
+                            readData();
+
+                            function readData() {
+
+                                reader.read().then(({ done, value }) => {
+
+                                    if (done) {
+
+                                        controller.close();
+
+                                    } else {
+
+                                        loaded += value.byteLength;
+
+                                        progress(loaded, length);
+
+                                        controller.enqueue(value);
+                                        readData();
+
+                                    }
+
+                                });
+
+                            }
+
+                        }
+
+                    });
+
+                    return new Response(stream);
+
+                } else {
+
+                    throw Error(`fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`);
 
-        if (coc.kind === CrossOriginKind.UseCredentials) {
-            xhr.withCredentials = true;
-        }
+                }
+            })
+            .then(async response => {
+                const arrayBuffer = await response.arrayBuffer();
 
-        xhr.addEventListener('load', function () {
-            if (xhr.readyState === xhr.DONE && xhr.status === 200) {
-                const arrayBuffer = xhr.response;
                 const asset = new Asset(
                     function () {
                         return arrayBuffer;
@@ -26,13 +90,9 @@ export class ArrayBufferLoader extends AssetLoader {
                 );
 
                 success(asset);
-            } else {
-                failure(xhr);
-            }
-        }, false);
+            })
+            .catch(failure);
 
-        xhr.addEventListener('error', failure, false);
 
-        xhr.send();
     }
 }

package/engine/ecs/EntityComponentDataset.js

@@ -949,11 +949,9 @@ export class EntityComponentDataset {
      */
     addComponentToEntity(entityIndex, componentInstance) {
 
-        if (!ENV_PRODUCTION) {
-            assert.notNull(componentInstance, "componentInstance");
+        assert.notNull(componentInstance, "componentInstance");
 
-            assert.defined(componentInstance, "componentInstance");
-        }
+        assert.defined(componentInstance, "componentInstance");
 
         const klass = componentInstance.constructor;
 
@@ -976,15 +974,13 @@ export class EntityComponentDataset {
      */
     addComponentToEntityByIndex(entityIndex, componentIndex, componentInstance) {
 
-        if (!ENV_PRODUCTION) {
+        assert.ok(this.entityExists(entityIndex), `entity ${entityIndex} does not exist`);
+        assert.ok(this.componentIndexExists(componentIndex), `componentIndex ${componentIndex} is out of bounds`);
 
-            assert.ok(this.entityExists(entityIndex), `entity ${entityIndex} does not exist`);
-            assert.ok(this.componentIndexExists(componentIndex), `componentIndex ${componentIndex} is out of bounds`);
+        assert.notEqual(componentInstance, undefined, "componentInstance is undefined");
 
-            assert.notEqual(componentInstance, undefined, "componentInstance is undefined");
+        assert.equal(this.getComponentByIndex(entityIndex, componentIndex), undefined, `entity ${entityIndex} already has component ${componentIndex}`);
 
-            assert.equal(this.getComponentByIndex(entityIndex, componentIndex), undefined, `entity ${entityIndex} already has component ${componentIndex}`);
-        }
 
         const componentOccupancyIndex = entityIndex * this.componentTypeCount + componentIndex;
 
@@ -1011,10 +1007,10 @@ export class EntityComponentDataset {
      * @returns {C|undefined}
      */
     getComponentByIndex(entityIndex, componentIndex) {
-        if (!ENV_PRODUCTION) {
-            assert.ok(this.entityExists(entityIndex), `entity ${entityIndex} does not exist`);
-            assert.ok(this.componentIndexExists(componentIndex), `componentIndex ${componentIndex} is out of bounds`);
-        }
+
+        assert.ok(this.entityExists(entityIndex), `entity ${entityIndex} does not exist`);
+        assert.ok(this.componentIndexExists(componentIndex), `componentIndex ${componentIndex} is out of bounds`);
+
 
         return this.components[componentIndex][entityIndex];
     }
@@ -1037,10 +1033,8 @@ export class EntityComponentDataset {
      * @returns {T|undefined}
      */
     getComponent(entityIndex, klass) {
-        if (!ENV_PRODUCTION) {
-            assert.ok(this.entityExists(entityIndex), `entity ${entityIndex} does not exist`);
-            assert.defined(klass, "klass");
-        }
+        assert.ok(this.entityExists(entityIndex), `entity ${entityIndex} does not exist`);
+        assert.defined(klass, "klass");
 
         const componentIndex = this.computeComponentTypeIndex(klass);
 
@@ -1078,11 +1072,9 @@ export class EntityComponentDataset {
      */
     traverseEntities(classes, visitor, thisArg) {
 
-        if (!ENV_PRODUCTION) {
-            assert.isArray(classes, "classes");
-            // assert.notOk(classes.some((c, i) => classes.indexOf(c) !== i), 'classes contains duplicates');
-            assert.isFunction(visitor, "visitor");
-        }
+        assert.isArray(classes, "classes");
+        // assert.notOk(classes.some((c, i) => classes.indexOf(c) !== i), 'classes contains duplicates');
+        assert.isFunction(visitor, "visitor");
 
         let entityIndex, i;
 
@@ -1152,7 +1144,7 @@ export class EntityComponentDataset {
     }
 
     /**
-     * does traversal on a subset of entities which have only the specified components.
+     * does traversal on a subset of entities which have only the specified components and no others
      * @example traverseEntitiesExact([Transform,Renderable,Tag],function(transform, renderable, tag, entity){ ... }, this);
      * @param {Array.<class>} classes
      * @param {Function} visitor
@@ -1472,10 +1464,8 @@ export class EntityComponentDataset {
      */
     addEntityEventListener(entity, eventName, listener, thisArg) {
 
-        if (!ENV_PRODUCTION) {
-            assert.isString(eventName,  "eventName");
-            assert.isFunction(listener,  "listener");
-        }
+        assert.isString(eventName, "eventName");
+        assert.isFunction(listener, "listener");
 
         if (!this.entityExists(entity)) {
             throw new Error(`Entity '${entity}' does not exist`);

package/engine/graphics/GraphicsEngine.d.ts

@@ -1,4 +1,4 @@
-import {PerspectiveCamera, Scene, WebGLRenderer, WebGLRenderTarget} from "three";
+import {PerspectiveCamera, Scene, WebGLRenderer} from "three";
 import {RenderLayerManager} from "./render/layers/RenderLayerManager";
 import Vector3 from "../../core/geom/Vector3";
 import Vector2 from "../../core/geom/Vector2";
@@ -28,7 +28,7 @@ export class GraphicsEngine {
     public needDraw: boolean
     public autoDraw: boolean
 
-    render(renderTarget?: WebGLRenderTarget): void
+    render(): void
 
     normalizeViewportPoint(input: Vector3 | Vector2, result: Vector2 | Vector3): void
 

package/engine/graphics/GraphicsEngine.js

@@ -11,8 +11,7 @@ import {
     Scene as ThreeScene,
     Vector3 as ThreeVector3,
     VSMShadowMap,
-    WebGLRenderer,
-    WebGLRenderTarget
+    WebGLRenderer
 } from "three";
 
 import Signal from "../../core/events/signal/Signal.js";
@@ -232,6 +231,12 @@ function GraphicsEngine(camera, entityManger) {
      * @type {boolean}
      */
     this.autoDraw = true;
+
+    /**
+     * Monotonically increasing rendered-frame counter
+     * @type {number}
+     */
+    this.frameIndex = 0;
 }
 
 /**
@@ -625,14 +630,14 @@ GraphicsEngine.prototype.renderTransparent = function () {
 
 /**
  *
- * @param {WebGLRenderTarget} [renderTarget] if not present - renders to screen
  */
-GraphicsEngine.prototype.render = function (renderTarget) {
-
+GraphicsEngine.prototype.render = function () {
     if (this.needDraw && !this.autoDraw) {
         this.needDraw = false;
     }
 
+    this.frameIndex++;
+
     const renderer = this.renderer;
 
     //reset renderer statistics (used for debug)
@@ -653,14 +658,10 @@ GraphicsEngine.prototype.render = function (renderTarget) {
 
     this.constructVisibleScene(renderer, camera, scene);
 
-    if (renderTarget !== undefined) {
-        renderer.setRenderTarget(renderTarget);
-    }
-
     //dispatch pre-render event
     this.on.preRender.send3(renderer, camera, scene);
 
-    this.main_view.on.preRender.send0();
+    this.main_view.on.preRender.send1(this.main_view);
 
     //do the opaque pass
     this.renderOpaque();
@@ -674,12 +675,7 @@ GraphicsEngine.prototype.render = function (renderTarget) {
 
     this.layerComposer.composite(renderer, CompositingStages.POST_TRANSPARENT);
 
-
     //dispatch post-render event
     this.on.postRender.send3(renderer, camera, scene);
-
-    if (renderTarget !== undefined) {
-        renderer.setRenderTarget(null);
-    }
 };
 export { GraphicsEngine };

package/engine/graphics/composit/LayerCompositer.js

@@ -50,6 +50,7 @@ class LayerCompositer {
 
         this.layerTargets.splice(i, 1);
 
+        // cleanup memory
         layer.renderTarget.dispose();
 
         return true;

package/engine/graphics/ecs/camera/Camera.js

@@ -8,11 +8,11 @@ import ObservedEnum from "../../../../core/model/ObservedEnum.js";
 import { Frustum } from 'three';
 import { assert } from "../../../../core/assert.js";
 import Vector1 from "../../../../core/geom/Vector1.js";
-import { computePointDistanceToPlane } from "../../../../core/geom/Plane.js";
 import { unprojectPoint } from "./unprojectPoint.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { frustum_from_camera } from "./frustum_from_camera.js";
 import { invertQuaternionOrientation } from "./InvertQuaternionOrientation.js";
+import { v3_distance_above_plane } from "../../../../core/geom/v3_distance_above_plane.js";
 
 /**
  *
@@ -248,7 +248,7 @@ export class Camera {
 
         const normal = near.normal;
 
-        const distance_to_plane = computePointDistanceToPlane(x, y, z, normal.x, normal.y, normal.z, near.constant);
+        const distance_to_plane = v3_distance_above_plane(x, y, z, normal.x, normal.y, normal.z, near.constant);
 
         const negative_distance_to_plane = -distance_to_plane;
 

package/engine/graphics/ecs/camera/CameraSystem.js

@@ -212,6 +212,12 @@ export class CameraSystem extends System {
                     return;
                 }
 
+                if(c.object.updateProjectionMatrix !== undefined) {
+                    c.object.updateProjectionMatrix();
+                    c.object.updateMatrix();
+                    c.object.updateMatrixWorld(true);
+                }
+
                 if (c.autoClip === true) {
                     auto_set_camera_clipping_planes(c, layers);
                 } else {

package/engine/graphics/ecs/light/binding/three/ThreeLightBinding.js

@@ -239,7 +239,7 @@ export class ThreeLightBinding extends LightBinding {
         const cameraView = this.__shadow_map.views[0];
 
         // signal that we're about to render this view
-        cameraView.on.preRender.send0();
+        cameraView.on.preRender.send1(cameraView);
 
         /**
          *

package/engine/graphics/ecs/mesh-v2/aggregate/prototypeSGMesh.js

@@ -20,10 +20,7 @@ import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
 import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/BehaviorComponent.js";
 import { OrbitingBehavior } from "../../../../../../model/game/util/behavior/OrbitingBehavior.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
-import { GizmoRenderingPlugin } from "../../../render/gizmo/GizmoRenderingPlugin.js";
-import { Gizmo } from "../../../render/gizmo/Gizmo.js";
 import { AABB3 } from "../../../../../core/bvh2/aabb3/AABB3.js";
-import { MicronRenderPlugin } from "../../../micron/plugin/MicronRenderPlugin.js";
 import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
 
 new EngineHarness().initialize({
@@ -38,8 +35,8 @@ new EngineHarness().initialize({
             new ShadedGeometryHighlightSystem(engine)
         );
 
-        config.addPlugin(GizmoRenderingPlugin);
-        config.addPlugin(MicronRenderPlugin);
+        // config.addPlugin(GizmoRenderingPlugin);
+        // config.addPlugin(MicronRenderPlugin);
 
         const gltfAssetLoader = new GLTFAssetLoader();
 
@@ -79,11 +76,11 @@ function make_grid(ecd, engine) {
                 radius: 5
             });
 
-            const ctx = {
-                time: Math.sin(i * Math.PI / (GRID_FREQUENCY_SIZE - 1)) + Math.cos(j * Math.PI / (GRID_FREQUENCY_SIZE - 1))
-            };
-
-            const color = [random(), random(), random(), 1];
+            // const ctx = {
+            //     time: Math.sin(i * Math.PI / (GRID_FREQUENCY_SIZE - 1)) + Math.cos(j * Math.PI / (GRID_FREQUENCY_SIZE - 1))
+            // };
+            //
+            // const color = [random(), random(), random(), 1];
 
             engine.graphics.on.preRender.add(() => {
 
@@ -93,16 +90,16 @@ function make_grid(ecd, engine) {
 
                 // mesh.getBoundingBox(bounds);
 
-                Gizmo.color = color;
-
-                Gizmo.draw_wire_cube(
-                    [
-                        bounds.getCenterX(), bounds.getCenterY(), bounds.getCenterZ()
-                    ],
-                    [
-                        bounds.getExtentsX(), bounds.getExtentsY(), bounds.getExtentsZ()
-                    ]
-                );
+                // Gizmo.color = color;
+                //
+                // Gizmo.draw_wire_cube(
+                //     [
+                //         bounds.getCenterX(), bounds.getCenterY(), bounds.getCenterZ()
+                //     ],
+                //     [
+                //         bounds.getExtentsX(), bounds.getExtentsY(), bounds.getExtentsZ()
+                //     ]
+                // );
             });
 
 

package/engine/graphics/filter/FlipArrayInPlace.js

@@ -5,21 +5,26 @@
  * @param {number} channel_count
  */
 export function flipArrayInPlace(input, width, height, channel_count = 4) {
-    const rowLength = width * channel_count;
+    const row_size = width * channel_count;
     let t, x0, x1;
     let i = 0;
-    const l = height >> 1;
+    const column_count = height >> 1;
+
+    for (; i < column_count; i++) {
 
-    for (; i < l; i++) {
         //swap lines
-        const k = (height - i - 1) * rowLength;
-        const m = i * rowLength;
-        for (let j = 0; j < rowLength; j++) {
+        const k = (height - i - 1) * row_size;
+        const m = i * row_size;
+
+        for (let j = 0; j < row_size; j++) {
             x0 = m + j;
             x1 = k + j;
+
             t = input[x0];
+
             input[x0] = input[x1];
             input[x1] = t;
         }
+
     }
 }

package/engine/graphics/geometry/clipping/ClippedGeometry.js

@@ -1,4 +1,4 @@
-import { computePointDistanceToPlane } from "../../../../core/geom/Plane.js";
+import { v3_distance_above_plane } from "../../../../core/geom/v3_distance_above_plane.js";
 
 
 // TODO incomplete
@@ -107,9 +107,9 @@ export class ClippedGeometry {
 
         const plane_constant = plane.constant;
 
-        const a_distance = computePointDistanceToPlane(a_x, a_y, a_z, normal_x, normal_y, normal_z, plane_constant);
-        const b_distance = computePointDistanceToPlane(b_x, b_y, b_z, normal_x, normal_y, normal_z, plane_constant);
-        const c_distance = computePointDistanceToPlane(c_x, c_y, c_z, normal_x, normal_y, normal_z, plane_constant);
+        const a_distance = v3_distance_above_plane(a_x, a_y, a_z, normal_x, normal_y, normal_z, plane_constant);
+        const b_distance = v3_distance_above_plane(b_x, b_y, b_z, normal_x, normal_y, normal_z, plane_constant);
+        const c_distance = v3_distance_above_plane(c_x, c_y, c_z, normal_x, normal_y, normal_z, plane_constant);
 
         const a_out = a_distance <= 0;
         const b_out = b_distance <= 0;

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -516,7 +516,9 @@ function init() {
     // gltf_sample('moicon/A4/A4/model.gltf');
     // gltf_sample('moicon/06_04_hapro/08-clickable-assets-new/model.gltf');
     // gltf_grid('moicon/ztest_object_many_pieces/model.gltf', 3, 3);
-    gltf_sample('moicon/ztest_object_many_pieces/model.gltf');
+    // gltf_sample('moicon/ztest_object_many_pieces/model.gltf');
+    // gltf_sample('moicon/62cf22227f7b8f0012ca5988/model.gltf');
+    gltf_sample('moicon/gnutti_not_optimized/model.gltf');
     // gltf_grid('data/models/moicon/Kople/EVCharger1.gltf');
     // gltf_sample('data/models/moicon/Kople/EVCharger1.gltf');
     // gltf_sample('data/models/moicon/isiflow_Oct_15_21/0/model.gltf');

package/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js

@@ -356,7 +356,9 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         this.__composit_layer.on.preRender.remove(this.__render, this);
         graphics.viewport.size.onChanged.add(this.__update_render_target_size, this);
 
+        // release memory
         this.__blur.dispose();
+        this.__render_target.dispose();
 
         return super.shutdown();
     }

package/engine/graphics/render/buffer/simple-fx/taa/TemporalSupersamplingRenderPlugin.js

@@ -0,0 +1,95 @@
+import { EnginePlugin } from "../../../../../plugin/EnginePlugin.js";
+import { halton_sequence } from "../../../../../../core/math/statistics/halton_sequence.js";
+import { array_copy } from "../../../../../../core/collection/array/copyArray.js";
+
+/**
+ * Generates a number of 2d jitter offsets in range -1...1
+ * @param {number} point_count
+ * @return {Float32Array}
+ */
+function generate_jitter(point_count) {
+    const result = new Float32Array(point_count * 2);
+
+    for (let i = 0; i < point_count; i++) {
+        const i2 = i * 2;
+        result[i2] = halton_sequence(2, i) * 2 - 1;
+        result[i2 + 1] = halton_sequence(3, i) * 2 - 1;
+    }
+
+    return result;
+}
+
+export class TemporalSupersamplingRenderPlugin extends EnginePlugin {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__frame_index = 0;
+
+        this.__sample_count = 16;
+        this.__jitter_offset = generate_jitter(this.__sample_count);
+
+
+        this.__projection_modifier = {
+            /**
+             *
+             * @param {number[]} input
+             * @param {number[]} output
+             */
+            transform: (input, output) => {
+
+                const viewport_width = this.engine.graphics.viewport.size.x;
+                const viewport_height = this.engine.graphics.viewport.size.y;
+
+                // apply jitter to projection matrix
+                const jitter_index = this.__frame_index % this.__sample_count;
+
+                const jitter_offset_x = this.__jitter_offset[jitter_index * 2];
+                const jitter_offset_y = this.__jitter_offset[jitter_index * 2 + 1];
+
+                array_copy(input, 0, output, 0, 16);
+
+                output[8] = jitter_offset_x / viewport_width;
+                output[9] = jitter_offset_y / viewport_height;
+            }
+        };
+    }
+
+    __hook_post_render() {
+
+        // increment frame index
+        this.__frame_index++;
+    }
+
+    initialize(engine) {
+        super.initialize(engine);
+    }
+
+    finalize() {
+        super.finalize();
+    }
+
+    async startup() {
+        // modify projection matrix
+        this.engine.graphics.main_view.addProjectionModifier(this.__projection_modifier);
+
+
+        this.engine.graphics.on.postRender.add(this.__hook_post_render, this);
+
+        // reset frame counter
+        this.__frame_index = 0;
+
+        return super.startup();
+    }
+
+    async shutdown() {
+        this.engine.graphics.main_view.removeProjectionModifier(this.__projection_modifier);
+        this.engine.graphics.on.postRender.remove(this.__hook_post_render, this);
+
+        return super.shutdown();
+    }
+}

package/engine/graphics/render/buffer/simple-fx/taa/prototypeTAA.js

@@ -0,0 +1,61 @@
+import { EngineHarness } from "../../../../../EngineHarness.js";
+import EntityBuilder from "../../../../../ecs/EntityBuilder.js";
+import { Transform } from "../../../../../ecs/transform/Transform.js";
+import { ShadedGeometry } from "../../../../ecs/mesh-v2/ShadedGeometry.js";
+import { BoxBufferGeometry, MeshStandardMaterial } from "three";
+import { ShadedGeometrySystem } from "../../../../ecs/mesh-v2/ShadedGeometrySystem.js";
+import { AmbientOcclusionPostProcessEffect } from "../ao/AmbientOcclusionPostProcessEffect.js";
+import { ShadedGeometryHighlightSystem } from "../../../../ecs/highlight/system/ShadedGeometryHighlightSystem.js";
+import { seededRandom } from "../../../../../../core/math/random/seededRandom.js";
+import Highlight from "../../../../ecs/highlight/Highlight.js";
+
+const eh = new EngineHarness();
+
+/**
+ *
+ * @param {Engine} engine
+ * @return {Promise<void>}
+ */
+async function main(engine) {
+    await EngineHarness.buildBasics({
+        engine
+    });
+
+    // add a bunch of cubes
+    const mat = new MeshStandardMaterial({ color: 0xFFFFFF });
+    const geo = new BoxBufferGeometry();
+
+    const random = seededRandom();
+
+    for (let i = 0; i < 5; i++) {
+        for (let j = 0; j < 5; j++) {
+            const entityBuilder = new EntityBuilder();
+
+            if (random() > 0.5) {
+                entityBuilder.add(Highlight.fromOne(random(), random(), random()));
+            }
+
+            entityBuilder
+                .add(Transform.fromJSON({
+                    position: {
+                        x: i * 2,
+                        z: j * 2,
+                        y: 0.5
+                    }
+                }))
+                .add(ShadedGeometry.from(geo, mat))
+                .build(engine.entityManager.dataset);
+        }
+    }
+}
+
+eh.initialize({
+    configuration(config, engine) {
+        // config.addPlugin(TemporalSupersamplingRenderPlugin);
+        config.addPlugin(AmbientOcclusionPostProcessEffect);
+
+        config.addSystem(new ShadedGeometrySystem(engine));
+
+        config.addSystem(new ShadedGeometryHighlightSystem(engine));
+    }
+}).then(main);

package/engine/graphics/render/forward_plus/LightManager.js

@@ -592,7 +592,7 @@ export class LightManager {
      * @private
      */
     __build_view_frustum(camera) {
-        frustum_from_camera(camera, this.__view_frustum);
+        frustum_from_camera(camera, this.__view_frustum, false);
 
         arraySwapElements(this.__view_frustum.planes, 4, 5);
 
@@ -1038,9 +1038,9 @@ export class LightManager {
      * @param {Camera|THREE.PerspectiveCamera} camera
      */
     buildTiles(camera) {
-        camera.updateProjectionMatrix();
-        camera.updateMatrix();
-        camera.updateMatrixWorld(true);
+        // camera.updateProjectionMatrix();
+        // camera.updateMatrix();
+        // camera.updateMatrixWorld(true);
 
         //update world inverse matrix
         camera.matrixWorldInverse.copy(camera.matrixWorld);