@woosh/meep-engine 2.62.0 → 2.64.0

package/src/engine/ecs/foliage/ecs/Foliage2System.js

@@ -1,333 +0,0 @@
-import { System } from "../../System.js";
-import { InstancedFoliage } from "../InstancedFoliage.js";
-import { Cache } from "../../../../core/cache/Cache.js";
-import { InstancedMeshComponent } from "./InstancedMeshComponent.js";
-import { guessAssetType } from "../../../asset/guessAssetType.js";
-
-
-/**
- *
- * @param {{state:FoliageLayerState, instances: InstancedFoliage}} layerData
- * @param {RenderLayer} renderLayer
- */
-function cleanupLayer(layerData, renderLayer) {
-    if (layerData.state === FoliageLayerState.Live) {
-        layerData.state = FoliageLayerState.Removed;
-    }
-}
-
-
-/**
- *
- * @param {InstancedMeshLayer} layer
- * @param {AssetManager} assetManager
- * @returns {Promise<InstancedFoliage>}
- */
-export function loadFoliageLayer(layer, assetManager) {
-    const instancedFoliage = layer.data;
-
-    instancedFoliage.castShadow = layer.castShadow.getValue();
-    instancedFoliage.receiveShadow = layer.receiveShadow.getValue();
-
-    const modelURL = layer.modelURL.getValue();
-
-    const mesh = new Promise(function (resolve, reject) {
-        const assetType = guessAssetType(modelURL);
-
-        if (assetType === null) {
-            reject(`Undetermined asset type for url='${modelURL}'`);
-        }
-
-        assetManager.get({
-            path: modelURL, type: assetType, callback: function (asset) {
-                const mesh = asset.create();
-                instancedFoliage.setInstance(mesh.geometry, mesh.material);
-
-                resolve();
-            }, failure: reject
-        });
-    });
-
-    const result = mesh.then(function () {
-        return instancedFoliage;
-    });
-
-    return result;
-}
-
-/**
- *
- * @param {InstancedMeshLayer} layer
- * @param {Cache<string, Promise<InstancedFoliage>>} cache
- * @param {AssetManager} assetManager
- * @returns {Promise<InstancedFoliage>}
- */
-function obtainLayer(layer, cache, assetManager) {
-    const key = JSON.stringify(layer.toJSON());
-
-    if (cache.contains(key)) {
-        return cache.get(key);
-    } else {
-        const result = loadFoliageLayer(layer, assetManager);
-        cache.put(key, result);
-        return result;
-    }
-}
-
-/**
- * @deprecated
- */
-export class Foliage2System extends System {
-    /**
-     *
-     * @param {AssetManager} assetManager
-     * @param {GraphicsEngine} graphicsEngine
-     * @constructor
-     * @extends {System.<InstancedMeshComponent>}
-     */
-    constructor(assetManager, graphicsEngine) {
-        super();
-
-        this.graphics = graphicsEngine;
-
-        /**
-         *
-         * @type {RenderLayer|null}
-         */
-        this.renderLayer = null;
-
-        this.dependencies = [InstancedMeshComponent];
-
-        /**
-         *
-         * @type {AssetManager}
-         */
-        this.assetManager = assetManager;
-        this.data = [];
-
-        this.layerCache = new Cache({ maxWeight: 10 });
-
-    }
-
-    startup(entityManager, readyCallback, errorCallback) {
-        this.entityManager = entityManager;
-
-        const graphics = this.graphics;
-
-        this.renderLayer = graphics.layers.create('instanced-mesh-system');
-
-        /**
-         *
-         * @type {CameraViewManager}
-         */
-        const views = graphics.views;
-
-        /**
-         *
-         * @type {List<CameraView>}
-         */
-        const view_list = views.elements;
-
-        view_list.forEach(this.__handle_view_added, this);
-
-        view_list.on.added.add(this.__handle_view_added, this);
-        view_list.on.removed.add(this.__handle_view_removed, this);
-
-        this.renderLayer.buildVisibleSet = (destination, destination_offset, view) => {
-            const data = this.data;
-            let additions = 0;
-
-            for (let entity in data) {
-
-                const layers = data[entity];
-                const layer_count = layers.length;
-
-                for (let i = 0; i < layer_count; i++) {
-                    /**
-                     * @type {{instances:InstancedFoliage}}
-                     */
-                    const layerData = layers[i];
-
-                    if (layerData.state === FoliageLayerState.Live) {
-                        /**
-                         *
-                         * @type {InstancedFoliage}
-                         */
-                        const instances = layerData.instances;
-
-                        const view_state = instances.update(view);
-
-                        const group = view_state.instances;
-
-                        if (group.getCount() <= 0) {
-                            //no visible instances, skip
-                            continue;
-                        }
-
-                        const mesh = group.mesh;
-
-                        destination[additions + destination_offset] = mesh;
-                        additions++;
-                    }
-
-                }
-            }
-
-            return additions;
-        };
-
-        readyCallback();
-    }
-
-    /**
-     *
-     * @param {CameraView} view
-     * @private
-     */
-    __handle_view_added(view) {
-        const em = this.entityManager;
-
-        if (em === null) {
-            return;
-        }
-
-        const ecd = em.dataset;
-
-        if (ecd === null) {
-            return;
-        }
-
-        ecd.traverseComponents(InstancedMeshComponent, im => {
-            im.add_view(view);
-        });
-    }
-
-
-    /**
-     *
-     * @param {CameraView} view
-     * @private
-     */
-    __handle_view_removed(view) {
-
-        const em = this.entityManager;
-
-        if (em === null) {
-            return;
-        }
-
-        const ecd = em.dataset;
-
-        if (ecd === null) {
-            return;
-        }
-
-        ecd.traverseComponents(InstancedMeshComponent, im => {
-            im.remove_view(view);
-        });
-    }
-
-    shutdown(entityManager, readyCallback, errorCallback) {
-        this.graphics.layers.remove(this.renderLayer);
-
-        this.graphics.views.elements.forEach(this.__handle_view_removed, this);
-        this.graphics.views.elements.on.added.remove(this.__handle_view_added, this);
-        this.graphics.views.elements.on.removed.remove(this.__handle_view_removed, this);
-
-        readyCallback();
-    }
-
-    reset() {
-        //drop data
-        this.data.length = 0;
-    }
-
-    /**
-     *
-     * @param {InstancedMeshComponent} instances
-     * @param entity
-     */
-    link(instances, entity) {
-        const layers = [];
-        const data = this.data;
-
-        data[entity] = layers;
-
-        const layerList = instances.layers;
-        const layer_count = layerList.length;
-
-        for (let i = 0; i < layer_count; i++) {
-            /**
-             *
-             * @type {InstancedMeshLayer}
-             */
-            const foliage_layer = layerList.get(i);
-
-            if (foliage_layer.data.geometry == null) {
-
-                const promise = obtainLayer(foliage_layer, this.layerCache, this.assetManager);
-
-                const layerData = {
-                    instances: null,
-                    state: FoliageLayerState.Loading
-                };
-
-                layers.push(layerData);
-
-                promise.then(function (instances) {
-                    layerData.instances = instances;
-
-                    if (layerData.state !== FoliageLayerState.Removed) {
-                        //add to render layer
-                        layerData.state = FoliageLayerState.Live;
-                    }
-                });
-
-            } else {
-
-                layers.push({
-                    instances: foliage_layer.data,
-                    state: FoliageLayerState.Live
-                });
-
-            }
-        }
-
-        //
-        this.graphics.views.elements.forEach(instances.add_view, instances);
-    }
-
-    /**
-     *
-     * @param {InstancedMeshComponent} instances
-     * @param {number} entity
-     */
-    unlink(instances, entity) {
-        const renderLayer = this.renderLayer;
-        const layers = this.data[entity];
-
-        const layer_count = layers.length;
-
-        for (let i = 0; i < layer_count; i++) {
-            const layerData = layers[i];
-            cleanupLayer(layerData, renderLayer);
-        }
-
-        this.graphics.views.elements.forEach(instances.remove_view, instances);
-
-        instances.dispose();
-
-        delete this.data[entity];
-    }
-}
-
-
-/**
- *
- * @enum {number}
- */
-const FoliageLayerState = {
-    Loading: 0,
-    Live: 1,
-    Removed: 2
-};

package/src/engine/ecs/foliage/ecs/InstancedMeshComponent.js

@@ -1,70 +0,0 @@
-import List from "../../../../core/collection/list/List.js";
-import {InstancedMeshLayer} from "./InstancedMeshLayer.js";
-
-
-/**
- * @deprecated use {@link ShadedGeometry} instead with instanced rendering
- */
-export class InstancedMeshComponent {
-    constructor() {
-        /**
-         *
-         * @type {List<InstancedMeshLayer>}
-         * @readonly
-         */
-        this.layers = new List();
-    }
-
-    /**
-     *
-     * @param {CameraView} view
-     */
-    add_view(view) {
-        const layers = this.layers;
-        const layer_count = layers.length;
-
-        for (let i = 0; i < layer_count; i++) {
-            const layer = layers.get(i);
-
-            layer.add_view(view);
-        }
-    }
-
-    /**
-     *
-     * @param {CameraView} view
-     */
-    remove_view(view) {
-        const layers = this.layers;
-        const layer_count = layers.length;
-
-        for (let i = 0; i < layer_count; i++) {
-            const layer = layers.get(i);
-
-            layer.remove_view(view);
-        }
-    }
-
-    toJSON() {
-        return this.layers.toJSON();
-    }
-
-    fromJSON(data) {
-        this.layers.fromJSON(data, InstancedMeshLayer);
-    }
-
-    dispose() {
-
-        const layers = this.layers;
-        const n = layers.length;
-
-        for (let i = 0; i < n; i++) {
-            const layer = layers.get(i);
-
-            layer.dispose();
-        }
-    }
-}
-
-InstancedMeshComponent.typeName = "InstancedMeshComponent";
-

package/src/engine/ecs/foliage/ecs/InstancedMeshLayer.js

@@ -1,138 +0,0 @@
-import { InstancedFoliage } from "../InstancedFoliage.js";
-import ObservedString from "../../../../core/model/ObservedString.js";
-import ObservedBoolean from "../../../../core/model/ObservedBoolean.js";
-import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
-import { Base64 } from "../../../../core/binary/Base64.js";
-import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
-
-export class InstancedMeshLayer {
-    constructor() {
-        /**
-         *
-         * @type {InstancedFoliage}
-         * @readonly
-         */
-        this.data = new InstancedFoliage();
-
-        /**
-         *
-         * @type {ObservedString}
-         * @readonly
-         */
-        this.modelURL = new ObservedString("");
-
-        /**
-         *
-         * @type {ObservedBoolean}
-         * @readonly
-         */
-        this.castShadow = new ObservedBoolean(false);
-
-        /**
-         *
-         * @type {ObservedBoolean}
-         * @readonly
-         */
-        this.receiveShadow = new ObservedBoolean(false);
-    }
-
-    /**
-     *
-     * @param {CameraView} view
-     */
-    add_view(view) {
-        this.data.add_view(view);
-    }
-
-    /**
-     *
-     * @param {CameraView} view
-     */
-    remove_view(view) {
-        this.data.remove_view(view);
-    }
-
-    dispose() {
-        this.data.dispose();
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    hash() {
-
-        return computeHashIntegerArray(
-            this.data.hash(),
-            this.modelURL.hash(),
-            this.castShadow.hashCode(),
-            this.receiveShadow.hashCode()
-        );
-
-    }
-
-    fromJSON(json) {
-        this.modelURL.fromJSON(json.modelURL);
-        this.castShadow.fromJSON(json.castShadow);
-        this.receiveShadow.fromJSON(json.receiveShadow);
-
-        const data = json.data;
-
-        if (data !== undefined) {
-            const arrayBuffer = Base64.decode(data);
-
-            const bb = new BinaryBuffer();
-            bb.fromArrayBuffer(arrayBuffer);
-
-            this.data.deserialize(bb);
-        } else {
-
-            this.data.clear();
-
-        }
-    }
-
-    toJSON() {
-
-
-        const result = {
-            modelURL: this.modelURL.toJSON(),
-            castShadow: this.castShadow.toJSON(),
-            receiveShadow: this.receiveShadow.toJSON()
-        };
-
-        const bb = new BinaryBuffer();
-        this.data.serialize(bb);
-        bb.trim();
-
-        const data_string = Base64.encode(bb.data);
-
-        result.data = data_string;
-
-        return result;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     */
-    toBinaryBuffer(buffer) {
-        this.modelURL.toBinaryBuffer(buffer);
-        this.castShadow.toBinaryBuffer(buffer);
-        this.receiveShadow.toBinaryBuffer(buffer);
-
-        this.data.serialize(buffer);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     */
-    fromBinaryBuffer(buffer) {
-        this.modelURL.fromBinaryBuffer(buffer);
-        this.castShadow.fromBinaryBuffer(buffer);
-        this.receiveShadow.fromBinaryBuffer(buffer);
-
-        this.data.deserialize(buffer);
-    }
-}

package/src/engine/ecs/foliage/ecs/InstancedMeshSerializationAdapter.js

@@ -1,28 +0,0 @@
-import { BinaryClassSerializationAdapter } from "../../storage/binary/BinaryClassSerializationAdapter.js";
-import { InstancedMeshComponent } from "./InstancedMeshComponent.js";
-import { InstancedMeshLayer } from "./InstancedMeshLayer.js";
-
-export class InstancedMeshSerializationAdapter extends BinaryClassSerializationAdapter {
-
-    klass = InstancedMeshComponent;
-    version = 0;
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {InstancedMeshComponent} value
-     */
-    serialize(buffer, value) {
-        value.layers.toBinaryBuffer(buffer);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {InstancedMeshComponent} value
-     */
-    deserialize(buffer, value) {
-
-        value.layers.fromBinaryBuffer(buffer, InstancedMeshLayer);
-    }
-}

package/src/engine/ecs/foliage/ecs/convertInstancedMeshComponents2Entities.js

@@ -1,64 +0,0 @@
-import {assert} from "../../../../core/assert.js";
-import Mesh from "../../../graphics/ecs/mesh/Mesh.js";
-import Entity from "../../Entity.js";
-import {Transform} from "../../transform/Transform.js";
-import {loadFoliageLayer} from "./Foliage2System.js";
-import {InstancedMeshComponent} from "./InstancedMeshComponent.js";
-
-/**
- * Convert all existing instanced mesh components to individual Transform+Mesh pairs
- * @param {EntityComponentDataset} dataset
- * @param assetManager
- */
-export function convertInstancedMeshComponents2Entities(dataset, assetManager) {
-    assert.notEqual(dataset, undefined, 'dataset is undefined');
-    assert.notEqual(assetManager, undefined, 'assetManager is undefined');
-
-    const entitiesToStrip = [];
-
-    /**
-     *
-     * @param {InstancedMeshComponent} foliage2
-     * @param entity
-     */
-    function visitFoliageEntities(foliage2, entity) {
-        foliage2.layers.forEach(function (layer) {
-            const modelURL = layer.modelURL.getValue();
-
-            loadFoliageLayer(layer, assetManager)
-                .then(function (instancedFoliage) {
-
-                    const data = instancedFoliage.data;
-                    const numInstances = data.length;
-
-                    for (let i = 0; i < numInstances; i++) {
-                        const transform = new Transform();
-
-                        instancedFoliage.read(i, transform.position, transform.rotation, transform.scale);
-
-                        const mesh = new Mesh();
-                        mesh.url = modelURL;
-
-                        mesh.castShadow = layer.castShadow.getValue();
-                        mesh.receiveShadow = layer.receiveShadow.getValue();
-
-                        //TODO Consider moving BVH info here also, to make this process faster
-
-                        const entityBuilder = new Entity();
-
-                        entityBuilder.add(transform).add(mesh).build(dataset);
-                    }
-                });
-        });
-
-        entitiesToStrip.push(entity);
-    }
-
-    dataset.traverseEntities([InstancedMeshComponent], visitFoliageEntities);
-
-    //remove converted foliage components
-    entitiesToStrip.forEach(function (entity) {
-        dataset.removeComponentFromEntity(entity, InstancedMeshComponent);
-    });
-}
-