@woosh/meep-engine 2.33.61 → 2.33.65

package/engine/ecs/terrain/util/loadVisibleTerrainTiles.js

@@ -0,0 +1,112 @@
+import TopDownCameraControllerSystem from "../../../graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js";
+import { Camera } from "../../../graphics/ecs/camera/Camera.js";
+import { obtainTerrain } from "./obtainTerrain.js";
+import { assert } from "../../../../core/assert.js";
+import TerrainSystem from "../ecs/TerrainSystem.js";
+import Task from "../../../../core/process/task/Task.js";
+import TaskSignal from "../../../../core/process/task/TaskSignal.js";
+
+/**
+ *
+ * @param {EntityManager} em
+ * @param {EntityComponentDataset} ecd
+ * @returns {Task}
+ */
+export function loadVisibleTerrainTiles(em, ecd) {
+
+    let totalTiles = 0;
+    let loadedTiles = 0;
+    let failedTiles = 0;
+
+    let attempt = 0;
+
+    let failureFlag = false;
+
+    function init() {
+        const attemptId = attempt;
+
+        //force update by camera controller, to ensure correct focus is set
+        em.getSystem(TopDownCameraControllerSystem).update(0);
+
+        ecd.traverseComponents(Camera, function (c) {
+            c.updateMatrices();
+        });
+
+        const tiles = [];
+
+        const terrain = obtainTerrain(ecd);
+
+        assert.notEqual(terrain, null, 'terrain not found');
+
+        TerrainSystem.traverseVisibleTiles(ecd, terrain, function (tile) {
+            tiles.push(tile);
+        });
+
+        totalTiles = tiles.length;
+        const tileManager = terrain.tiles;
+
+        function handleObtainedTile(t) {
+            if (attemptId !== attempt) {
+                return;
+            }
+
+            loadedTiles++;
+        }
+
+        function handleFailedTile(t) {
+            if (attemptId !== attempt) {
+                return;
+            }
+
+            attempt++;
+
+            failedTiles++;
+
+            if (attempt < 10) {
+                init();
+            } else {
+                failureFlag = true;
+            }
+        }
+
+        if (totalTiles !== 0) {
+            tiles.forEach(function (tile) {
+                tileManager.obtain(tile.gridPosition.x, tile.gridPosition.y).then(handleObtainedTile, handleFailedTile);
+            });
+        }
+    }
+
+    const task = new Task({
+        name: "Building visible terrain tiles",
+
+        initializer: init,
+
+        cycleFunction() {
+            if (failureFlag) {
+                return TaskSignal.EndFailure;
+            }
+
+            if (loadedTiles >= totalTiles) {
+                return TaskSignal.EndSuccess;
+            } else {
+                return TaskSignal.Yield;
+            }
+        },
+
+        computeProgress() {
+            if (totalTiles === 0) {
+                return 0;
+            }
+
+            const f = loadedTiles / totalTiles;
+
+            if (f >= 1) {
+                return 1;
+            }
+
+            return f;
+        }
+    });
+
+    return task;
+}

package/engine/ecs/terrain/util/obtainTerrain.js

@@ -0,0 +1,23 @@
+import { assert } from "../../../../core/assert.js";
+import Terrain from "../ecs/Terrain.js";
+
+/**
+ *
+ * @param {EntityComponentDataset} ecd
+ * @param {function(terrain:Terrain,entity:number)} [callback]
+ * @returns {Terrain|null}
+ */
+export function obtainTerrain(ecd, callback) {
+    assert.notEqual(ecd, null, 'ecd is null');
+    assert.notEqual(ecd, undefined, 'ecd is undefined');
+
+    const object = ecd.getAnyComponent(Terrain);
+
+    const terrain = object.component;
+
+    if (terrain !== null && typeof callback === "function") {
+        callback(terrain, object.entity);
+    }
+
+    return terrain;
+}

package/engine/ecs/tooltip/TooltipComponentSystem.js

@@ -2,10 +2,10 @@ import { System } from "../System.js";
 import { TooltipComponent } from "./TooltipComponent.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { MeshSystem } from "../../graphics/ecs/mesh/MeshSystem.js";
-import { modelHitTest } from "../../../../model/game/util/ScreenGridPicker.js";
 import { SurfacePoint3 } from "../../../core/geom/3d/SurfacePoint3.js";
 import { VisualTip } from "../../../view/tooltip/VisualTip.js";
 import Rectangle from "../../../core/geom/Rectangle.js";
+import { modelHitTest } from "../../graphics/util/modelHitTest.js";
 
 const ray_source = new Vector3();
 const ray_direction = new Vector3();

package/engine/graphics/ecs/camera/topdown/TopDownCameraLanderSystem.js

@@ -2,11 +2,11 @@ import { clamp } from "../../../../../core/math/clamp.js";
 import { System } from "../../../../ecs/System.js";
 import { TopDownCameraLander } from "./TopDownCameraLander.js";
 import { Cache } from "../../../../../core/cache/Cache.js";
-import { obtainTerrain } from "../../../../../../model/game/scenes/SceneUtils.js";
 import { buildCameraTargetSampler } from "../../../../input/ecs/util/TerrainCameraTargetSampler.js";
 import TopDownCameraController from "./TopDownCameraController.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
 import { SignalBinding } from "../../../../../core/events/signal/SignalBinding.js";
+import { obtainTerrain } from "../../../../ecs/terrain/util/obtainTerrain.js";
 
 
 /**

package/engine/graphics/ecs/water/WaterSystem.js

@@ -8,10 +8,10 @@ import { LeafNode } from '../../../../core/bvh2/LeafNode.js';
 import { buildPlanarRenderLayerClipPlaneComputationMethod } from "../../render/layers/RenderLayerUtils.js";
 import ThreeFactory from "../../three/ThreeFactory.js";
 import { RenderPassType } from "../../render/RenderPassType.js";
-import { obtainTerrain } from "../../../../../model/game/scenes/SceneUtils.js";
 import { makeAlexWaterMaterial } from "../water2/shader/AlexWaterShader.js";
 import { threeUpdateTransform } from "../../util/threeUpdateTransform.js";
 import { StandardFrameBuffers } from "../../StandardFrameBuffers.js";
+import { obtainTerrain } from "../../../ecs/terrain/util/obtainTerrain.js";
 
 const WATER_SIZE = 800;
 

package/engine/graphics/ecs/water2/shader/testWaterShader.js

@@ -1,4 +1,3 @@
-import { obtainTerrain } from "../../../../../../model/game/scenes/SceneUtils.js";
 import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
 import { EngineConfiguration } from "../../../../EngineConfiguration.js";
 import ScriptSystem from "../../../../ecs/systems/ScriptSystem.js";
@@ -28,6 +27,7 @@ import { EngineHarness } from "../../../../EngineHarness.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
 import Vector3 from "../../../../../core/geom/Vector3.js";
 import SimplexNoise from 'simplex-noise';
+import { obtainTerrain } from "../../../../ecs/terrain/util/obtainTerrain.js";
 
 const engineHarness = new EngineHarness();
 

package/engine/graphics/geometry/AttributeSpec.d.ts

@@ -0,0 +1,8 @@
+import {DataType} from "../../../core/parser/simple/DataType";
+
+export class AttributeSpec {
+    readonly name: string
+    readonly type: DataType
+    readonly itemSize: number
+    readonly normalized: boolean
+}

package/engine/graphics/geometry/VertexDataSpec.d.ts

@@ -0,0 +1,15 @@
+import {AttributeSpec} from "./AttributeSpec";
+
+export class VertexDataSpec {
+    readonly attributes: AttributeSpec[]
+
+    getAttributeByName(name: string): AttributeSpec | undefined
+
+    add(attribute: AttributeSpec): this
+
+    setAttributes(attributes: AttributeSpec[]): void
+
+    equals(other: VertexDataSpec): boolean
+
+    hash(): number
+}

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

@@ -0,0 +1,39 @@
+import { BufferAttribute } from "three";
+
+
+/**
+ *
+ * @param {THREE.InterleavedBufferAttribute|THREE.BufferAttribute} source_attribute
+ * @returns {THREE.BufferAttribute}
+ */
+export function deinterleaveBufferAttribute(source_attribute) {
+    if (source_attribute.isInterleavedBufferAttribute !== true && source_attribute.isBufferAttribute) {
+        return source_attribute;
+    }
+
+    const source_data = source_attribute.data;
+    const source_data_array = source_data.array;
+    const stride = source_data.stride;
+
+    const item_count = source_attribute.count;
+    const itemSize = source_attribute.itemSize;
+    const array_size = item_count * itemSize;
+
+    const offset = source_attribute.offset;
+
+    const destination_array = new source_data_array.constructor(array_size);
+
+    const attribute = new BufferAttribute(destination_array, itemSize);
+
+    attribute.normalized = source_attribute.normalized;
+    attribute.name = source_attribute.name;
+
+    // copy data
+    for (let i = 0; i < item_count; i++) {
+        for (let j = 0; j < itemSize; j++) {
+            destination_array[i * itemSize + j] = source_data_array[i * stride + offset + j];
+        }
+    }
+
+    return attribute;
+}

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

@@ -0,0 +1,50 @@
+import { BufferGeometry } from "three";
+import { deinterleaveBufferAttribute } from "./deinterleaveBufferAttribute.js";
+
+/**
+ *
+ * @param {THREE.BufferGeometry} geometry
+ * @returns {THREE.BufferGeometry}
+ */
+export function deinterleaveBufferGeometry(geometry) {
+    const result = new BufferGeometry();
+
+    if (geometry.getIndex() !== null) {
+        result.setIndex(deinterleaveBufferAttribute(geometry.getIndex()));
+    }
+
+    for (const attribute_key in geometry.attributes) {
+        const source_attribute = geometry.attributes[attribute_key];
+
+        result.setAttribute(attribute_key, deinterleaveBufferAttribute(source_attribute));
+    }
+
+    // copy other bits
+    result.name = geometry.name;
+
+    result.morphTargetsRelative = geometry.morphTargetsRelative;
+
+    for (const attribute_key in geometry.morphAttributes) {
+        const source_attributes = geometry.morphAttributes[attribute_key];
+
+        const result_attributes = [];
+
+        result.morphAttributes[attribute_key] = result_attributes;
+
+        for (let i = 0; i < source_attributes.length; i++) {
+            const source_attribute = source_attributes[i];
+            result_attributes[i] = deinterleaveBufferAttribute(source_attribute);
+        }
+    }
+
+    result.groups = geometry.groups.slice();
+
+
+    result.boundingBox = geometry.boundingBox !== null ? geometry.boundingBox.clone() : null;
+    result.boundingSphere = geometry.boundingSphere !== null ? geometry.boundingSphere.clone() : null;
+    result.drawRange.start = geometry.drawRange.start;
+    result.drawRange.count = geometry.drawRange.count;
+    result.userData = JSON.parse(JSON.stringify(geometry.userData));
+
+    return result;
+}

package/engine/graphics/micron/MICRON_GEOMETRY_FIELD.js

@@ -0,0 +1 @@
+export const MICRON_GEOMETRY_FIELD = '@micron_geometry';

package/engine/graphics/micron/MICRON_URI_FIELD.js

@@ -0,0 +1 @@
+export const MICRON_URI_FIELD = '@micron_path';

package/engine/graphics/micron/build/buildMicronGeometryFromBufferGeometry.js

@@ -12,6 +12,7 @@ import { expandConnectivityByLocality } from "../../../../core/geom/3d/topology/
 import { build_geometry_info } from "./build_geometry_info.js";
 import { build_leaf_patches_metis } from "./clustering/build_leaf_patches_metis.js";
 import { compute_buffer_geometry_byte_size } from "../../geometry/buffered/compute_buffer_geometry_byte_size.js";
+import { deinterleaveBufferGeometry } from "../../geometry/buffered/deinterleaveBufferGeometry.js";
 
 /**
  * Returns current time in milliseconds
@@ -105,11 +106,13 @@ const PRINT_VERBOSE_STATS = false;
  * @returns {MicronGeometry}
  */
 export async function buildMicronGeometryFromBufferGeometry(input) {
+    const source_geometry = deinterleaveBufferGeometry(input);
+
     // build topology representation
     const topoMesh = new TopoMesh();
 
-    const position_attribute = input.getAttribute("position");
-    const index_attribute = input.index;
+    const position_attribute = source_geometry.getAttribute("position");
+    const index_attribute = source_geometry.index;
 
     const face_index_array = index_attribute.array;
     const vertex_position_array = position_attribute.array;
@@ -183,18 +186,18 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
 
     const r = new MicronGeometry();
 
-    r.proxy = input; // TODO use r.buildProxy(1) instead
+    r.proxy = source_geometry; // TODO use r.buildProxy(1) instead
 
     r.source_triangle_count = index_attribute.count / 3;
-    r.source_vertex_count = input.getAttribute('position').count;
-    r.source_byte_size = compute_buffer_geometry_byte_size(input);
+    r.source_vertex_count = source_geometry.getAttribute('position').count;
+    r.source_byte_size = compute_buffer_geometry_byte_size(source_geometry);
 
     // console.time('build geometry');
 
-    const vertex_attributes = attributes_from_buffer_geometry(input);
+    const vertex_attributes = attributes_from_buffer_geometry(source_geometry);
 
     r.vertex_spec.setAttributes(vertex_attributes);
-    r.root = compilePatchGraph(root, input, r.vertex_spec);
+    r.root = compilePatchGraph(root, source_geometry, r.vertex_spec);
 
     r.initialize();
 

package/engine/graphics/micron/convert_three_object_to_micron.js

@@ -4,6 +4,7 @@ import { computeGeometryEquality } from "../../asset/loaders/geometry/geometry/c
 import { buildMicronGeometryFromBufferGeometry } from "./build/buildMicronGeometryFromBufferGeometry.js";
 import { ThreeMicronMesh } from "./format/ThreeMicronMesh.js";
 import { AsyncMapWrapper } from "../../../core/collection/map/AsyncMapWrapper.js";
+import { MICRON_GEOMETRY_FIELD } from "./MICRON_GEOMETRY_FIELD.js";
 
 /**
  *
@@ -19,7 +20,6 @@ const pending_cache = new HashMap({
     keyEqualityFunction: computeGeometryEquality
 });
 
-
 /**
  *
  * @param {THREE.Object3D} object
@@ -36,6 +36,13 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
      * @returns {MicronGeometry}
      */
     async function obtain_geometry(g) {
+        const attached_micron = g[MICRON_GEOMETRY_FIELD];
+
+        if (attached_micron !== undefined && attached_micron.isMicronGeometry) {
+            // micron geometry is already attached, use it
+            return attached_micron;
+        }
+
         const existing = await micron_cache.get(g);
 
         if (existing !== undefined && existing !== null) {
@@ -90,7 +97,15 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
             && !mesh.isSkinnedMesh // skinned meshes not supported
         ) {
 
-            const micronGeometry = await obtain_geometry(mesh.geometry);
+            let micronGeometry;
+            try {
+                micronGeometry = await obtain_geometry(mesh.geometry);
+            } catch (e) {
+                console.error(`Failed to convert geometry to micron, skipping : ${e}`);
+
+                // return original
+                return mesh;
+            }
 
             const micron_mesh = new ThreeMicronMesh(micronGeometry, mesh.material);
 

package/engine/graphics/micron/format/MicronGeometry.d.ts

@@ -1,5 +1,9 @@
 import {BufferGeometry} from "three";
+import {VertexDataSpec} from "../../geometry/VertexDataSpec";
 
 export class MicronGeometry {
+    vertex_spec: VertexDataSpec
     public proxy: BufferGeometry
+
+    initialize(): void
 }

package/engine/graphics/micron/format/MicronGeometry.js

@@ -117,3 +117,9 @@ export class MicronGeometry {
         return this.__patches[id];
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+MicronGeometry.prototype.isMicronGeometry = true;

package/engine/graphics/micron/plugin/MicronRenderPlugin.js

@@ -13,6 +13,13 @@ import { AsyncRemoteHashMap } from "../../../../core/collection/map/AsyncRemoteH
 import { BufferGeometrySerializationAdapter } from "./serialization/BufferGeometrySerializationAdapter.js";
 import { MicronGeometryBinarySerializationAdapter } from "../format/serialization/MicronGeometryBinarySerializationAdapter.js";
 import { AsyncMapWrapper } from "../../../../core/collection/map/AsyncMapWrapper.js";
+import { async_traverse_three_object } from "../../../asset/loaders/async_traverse_three_object.js";
+import { computePathDirectory } from "../../../../core/FilePath.js";
+import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { MicronGeometry } from "../format/MicronGeometry.js";
+import { ArrayBufferLoader } from "../../../asset/loaders/ArrayBufferLoader.js";
+import { MICRON_URI_FIELD } from "../MICRON_URI_FIELD.js";
+import { MICRON_GEOMETRY_FIELD } from "../MICRON_GEOMETRY_FIELD.js";
 
 /**
  *
@@ -20,6 +27,7 @@ import { AsyncMapWrapper } from "../../../../core/collection/map/AsyncMapWrapper
  */
 const STORAGE_KEY = '@plugin/virtual-geometry-micron/geometry-cache';
 
+const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
 
 class GLTFAssetTransformer extends AssetTransformer {
     /**
@@ -35,17 +43,97 @@ class GLTFAssetTransformer extends AssetTransformer {
          * @private
          */
         this.__cache = cache;
+
+        /**
+         *
+         * @type {AssetManager|null}
+         * @private
+         */
+        this.__am = null;
+
+        /**
+         *
+         * @type {MicronGeometryBinarySerializationAdapter}
+         * @private
+         */
+        this.__serde = new MicronGeometryBinarySerializationAdapter();
+    }
+
+    /**
+     *
+     * @param {AssetManager|null} am
+     */
+    set assetManager(am) {
+        this.__am = am;
+    }
+
+
+    /**
+     * @param {THREE.Object3D} object
+     * @param {{asset:AssetDescription}} ctx
+     * @return {Promise<void>}
+     * @private
+     */
+    async __visitObjectToLoadMicron(object, ctx) {
+        if (!object.isMesh) {
+            return;
+        }
+
+        /**
+         * @type {THREE.BufferGeometry}
+         */
+        const geometry = object.geometry;
+
+        const micron_uri = geometry.userData[MICRON_URI_FIELD];
+
+        if (typeof micron_uri !== "string") {
+            return;
+        }
+
+
+        /**
+         * @type {AssetDescription}
+         */
+        const ad = ctx.asset;
+
+        const base = computePathDirectory(ad.path);
+
+        const micron_data = await this.__am.promise(`${base}/${micron_uri}`, ASSET_TYPE_ARRAY_BUFFER);
+
+        // deserialize micron data
+        const buffer = BinaryBuffer.fromArrayBuffer(micron_data.create());
+        const micron_geometry = new MicronGeometry();
+
+        this.__serde.deserialize(buffer, micron_geometry);
+
+        geometry[MICRON_GEOMETRY_FIELD] = micron_geometry;
     }
 
-    async transform(source) {
+
+    /**
+     *
+     * @param {Asset} source
+     * @param asset_description
+     * @return {Promise<Asset>}
+     */
+    async transform(source, asset_description) {
         const animationClips = source.animations;
+
         if (animationClips !== undefined && animationClips.length > 0) {
             // not suitable
             return source;
         }
 
+        /**
+         * @type {THREE.Object3D}
+         */
         const root = source.create();
 
+        // attempt to load existing micron geometries
+        await async_traverse_three_object(root, this.__visitObjectToLoadMicron, this, {
+            asset: asset_description
+        });
+
         const micron_root = await convert_three_object_to_micron(root.clone(), this.__cache);
         micron_root.boundingSphere = root.boundingSphere;
 
@@ -117,7 +205,7 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         /**
          *
-         * @type {AssetTransformer}
+         * @type {GLTFAssetTransformer}
          * @private
          */
         this.__asset_transformer = new GLTFAssetTransformer(this.__cache);
@@ -180,8 +268,17 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         const engine = this.engine;
 
-        engine.assetManager.registerTransformer("model/gltf", this.__asset_transformer);
-        engine.assetManager.registerTransformer("model/gltf+json", this.__asset_transformer);
+        const am = engine.assetManager;
+
+        // ensure that "arraybuffer" asset loader is present
+        if (am.getLoaderByType(ASSET_TYPE_ARRAY_BUFFER) === undefined) {
+            am.registerLoader(ASSET_TYPE_ARRAY_BUFFER, new ArrayBufferLoader());
+        }
+
+        this.__asset_transformer.assetManager = am;
+
+        am.registerTransformer("model/gltf", this.__asset_transformer);
+        am.registerTransformer("model/gltf+json", this.__asset_transformer);
 
         /**
          *
@@ -207,8 +304,12 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         this.__persisted_geometry.detach_storage();
 
-        engine.assetManager.unregisterTransformer("model/gltf", this.__asset_transformer);
-        engine.assetManager.unregisterTransformer("model/gltf+json", this.__asset_transformer);
+        const am = engine.assetManager;
+
+        am.unregisterTransformer("model/gltf", this.__asset_transformer);
+        am.unregisterTransformer("model/gltf+json", this.__asset_transformer);
+
+        this.__asset_transformer.assetManager = null;
 
         const ge = engine.graphics;
 

package/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -42,8 +42,6 @@ import { RepeatBehavior } from "../../../../../../intelligence/behavior/decorato
 import { ActionBehavior } from "../../../../../../intelligence/behavior/primitive/ActionBehavior.js";
 import { pingpong } from "../../../../../../../core/math/pingpong.js";
 import { ParameterLookupTable } from "../../parameter/ParameterLookupTable.js";
-import { pick } from "../../../../../../../../model/game/util/ScreenGridPicker.js";
-import { obtainTerrain } from "../../../../../../../../model/game/scenes/SceneUtils.js";
 import GUIElement from "../../../../../../ecs/gui/GUIElement.js";
 import EmptyView from "../../../../../../../view/elements/EmptyView.js";
 import HeadsUpDisplay from "../../../../../../ecs/gui/hud/HeadsUpDisplay.js";
@@ -77,6 +75,8 @@ import { UnitSphereShape3D } from "../../../../../../../core/geom/3d/shape/UnitS
 import TopDownCameraController from "../../../../../ecs/camera/topdown/TopDownCameraController.js";
 import { randomFloatBetween } from "../../../../../../../core/math/random/randomFloatBetween.js";
 import { MicronRenderPlugin } from "../../../../../micron/plugin/MicronRenderPlugin.js";
+import { obtainTerrain } from "../../../../../../ecs/terrain/util/obtainTerrain.js";
+import { pick } from "../../../../../../../ecs/grid/pick.js";
 
 const engineHarness = new EngineHarness();
 
@@ -433,7 +433,9 @@ async function sample_scene_nam(engine) {
         "distanceMax": 1000
     });
 
-    load_model('moicon/20_Dec_2021_Nammo/with_assets(for_alex)/model.gltf', ecd)
+    // load_model('moicon/20_Dec_2021_Nammo/with_assets(for_alex)/model.gltf', ecd)
+    load_model('moicon/20_Dec_2021_Nammo/with_assets_micron_conveted/model.gltf', ecd)
+    // load_model('moicon/micron_container/model.gltf', ecd)
 
     const P_SIZE_SMALL = 0.15;
     const P_SIZE_MEDIUM = 0.6;

package/engine/graphics/render/forward_plus/plugin/ptototypeFPPlugin.js

@@ -69,7 +69,6 @@ import Renderable from "../../../../ecs/components/Renderable.js";
 import { makeHelperSphereGeometry } from "../../../../../editor/process/symbolic/makeHelperSphereGeometry.js";
 import TopDownCameraController from "../../../ecs/camera/topdown/TopDownCameraController.js";
 import ThreeFactory from "../../../three/ThreeFactory.js";
-import { obtainTerrain } from "../../../../../../model/game/scenes/SceneUtils.js";
 import { JsonAssetLoader } from "../../../../asset/loaders/JsonAssetLoader.js";
 import { TextureAssetLoader } from "../../../../asset/loaders/texture/TextureAssetLoader.js";
 import { GameAssetType } from "../../../../asset/GameAssetType.js";
@@ -81,8 +80,9 @@ import { ParticleEmitterSystem } from "../../../particles/ecs/ParticleEmitterSys
 import { ShadedGeometrySystem } from "../../../ecs/mesh-v2/ShadedGeometrySystem.js";
 import { FogOfWar } from "../../../../ecs/fow/FogOfWar.js";
 import { FogOfWarRevealer } from "../../../../ecs/fow/FogOfWarRevealer.js";
-import Team from "../../../../../../model/game/ecs/component/Team.js";
+import Team from "../../../../ecs/team/Team.js";
 import { AmbientOcclusionPostProcessEffect } from "../../buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
+import { obtainTerrain } from "../../../../ecs/terrain/util/obtainTerrain.js";
 
 const geo_light_center_octahedron = new BoxBufferGeometry(0.1, 0.1, 0.1);
 const engineHarness = new EngineHarness();