@combeenation/3d-viewer 14.0.1-rc1 → 15.0.0

package/dist/lib-cjs/manager/model-manager.js

@@ -1,383 +1,383 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelManager = void 0;
-const index_1 = require("../index");
-const cloning_helper_1 = require("../internal/cloning-helper");
-const metadata_helper_1 = require("../internal/metadata-helper");
-const lodash_es_1 = require("lodash-es");
-/**
- * Manager for handling 3d models.\
- * Responsible for loading models and handling their visibility.\
- * Also contains advanced features like model cloning.
- */
-class ModelManager {
-    constructor(viewer) {
-        this.viewer = viewer;
-        this._modelAssets = {};
-        this._fallbackModelAsset = {
-            name: ModelManager.CBN_FALLBACK_MODEL_ASSET_NAME,
-            url: '',
-            state: 'loaded',
-            assetContainer: new index_1.AssetContainer(),
-            isClone: false,
-        };
-        this._loadModelPromises = {};
-    }
-    get modelNames() {
-        return Object.keys(this._modelAssets);
-    }
-    /**
-     * Nested models were targeted with slash notation previously, as Spec couldn't work with dots.
-     * Dots were interpreted as inherited model.
-     * Now the Hive viewer parameters are returning slash notated asset names, whereas the asset names from the
-     * prepacked asset manager are dot notated.
-     * This function converts slash to dot notation, so that models can be target with slash and dot notation alike.
-     */
-    static _replaceSlashes(inputStr) {
-        return inputStr.split('/').join('.');
-    }
-    /**
-     * Creates content for the fallback model, which is actually just a black cube.
-     * This is used for 3d assets that are linked in a data source but not available (yet).
-     * The Combeenation backend exchanges the missing 3d asset name with "$fallback", which indicates that we shouldn't
-     * throw an error but just show the fallback model instead.
-     *
-     * @internal
-     */
-    createFallbackModel() {
-        const fallbackCube = index_1.MeshBuilder.CreateBox('$fallbackCube', { size: 1 }, this.viewer.scene);
-        fallbackCube._parentContainer = this._fallbackModelAsset.assetContainer;
-        this._fallbackModelAsset.assetContainer.meshes.push(fallbackCube);
-        // NOTE: this is theoretically async, but in reality it's not when getting the material description from the CBN
-        // server
-        // also this is just a fallback that shouldn't be relevant in productive configurators
-        this.viewer.materialManager.setMaterialOnMesh(index_1.MaterialManager.CBN_FALLBACK_MATERIAL_NAME, fallbackCube);
-        this._fallbackModelAsset.assetContainer.removeFromScene();
-    }
-    /**
-     * Register models for 3d viewer, this is required for each model before it can be loaded/shown.\
-     * The "viewer control" inside the Combeenation framework calls this function automatically with all assigned
-     * 3d assets.
-     */
-    registerModels(modelAssets) {
-        for (const { name, url } of modelAssets) {
-            const existingModel = this._modelAssets[name];
-            if (existingModel) {
-                console.warn(`Model ${name} is already registered`);
-                return;
-            }
-            const model = { name, url, state: 'notLoaded', assetContainer: new index_1.AssetContainer(), isClone: false };
-            this._modelAssets[name] = model;
-        }
-    }
-    /**
-     * Loads the model and all it's assigned materials.\
-     * This function should be used for "eager loading" of models, so that model switching will be instant in the
-     * process.\
-     * If you don't plan to do this, just use {@link setModelVisibility} as this function will load the model under the
-     * hood the first time the model gets visible.
-     */
-    loadModel(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const model = this._getModel(name);
-            if (!model) {
-                throw new index_1.ViewerError({
-                    id: index_1.ViewerErrorIds.ModelNotRegistered,
-                    message: `Can't load model "${name}" as model is not registered`,
-                });
-            }
-            if (model.state !== 'notLoaded') {
-                console.warn(`Model ${name} is already loaded or currently loading`);
-                return;
-            }
-            yield this._loadModel(model);
-            yield this._prepareModelForScene(model);
-        });
-    }
-    /**
-     * Enables/disables multiple one or multiple models simultaniously.\
-     * All required models are loaded before adjusting the visibility to avoid flashing in the 3d scene.
-     *
-     * @returns Array of changed visibility status, combined with the corresponding model name
-     */
-    setModelVisibility(modelVisibility) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const showModels = [];
-            const hideModels = [];
-            if (!(0, lodash_es_1.isArray)(modelVisibility)) {
-                modelVisibility = [modelVisibility];
-            }
-            for (const entry of modelVisibility) {
-                const model = this._getModel(entry.name);
-                if (!model) {
-                    throw new index_1.ViewerError({
-                        id: index_1.ViewerErrorIds.ModelNotRegistered,
-                        message: `Can't set visibility of model "${entry.name}" as model is not registered`,
-                    });
-                }
-                // there can be multiple "setModelVisibility" calls while the model is loading
-                // loading can be awaited, but it has to be ensured, that the last call of "setModelVisibility" has priority
-                // therefore we store the id of the call in the model
-                const curVisibilityCallId = ((_a = model.visibilityCallId) !== null && _a !== void 0 ? _a : 0) + 1;
-                model.visibilityCallId = curVisibilityCallId;
-                if (entry.visible) {
-                    if (model.state === 'notLoaded') {
-                        yield this._loadModel(model);
-                        // check if this is still the latest visibility call
-                        if (model.visibilityCallId === curVisibilityCallId) {
-                            showModels.push(model);
-                        }
-                    }
-                    else if (model.state === 'loading') {
-                        yield this._loadModelPromises[model.name];
-                        if (model.visibilityCallId === curVisibilityCallId) {
-                            showModels.push(model);
-                        }
-                    }
-                    else if (model.state === 'loaded') {
-                        showModels.push(model);
-                    }
-                }
-                else {
-                    if (model.state === 'loading') {
-                        yield this._loadModelPromises[model.name];
-                        if (model.visibilityCallId === curVisibilityCallId) {
-                            hideModels.push(model);
-                        }
-                    }
-                    else if (model.state === 'inScene') {
-                        hideModels.push(model);
-                    }
-                }
-            }
-            for (const showModel of showModels) {
-                yield this._prepareModelForScene(showModel);
-            }
-            for (const showModel of showModels) {
-                yield this._showModel(showModel, true);
-            }
-            for (const hideModel of hideModels) {
-                this._hideModel(hideModel);
-            }
-            const returnVal = [];
-            showModels.forEach(showModel => returnVal.push({ name: showModel.name, visible: true }));
-            hideModels.forEach(hideModel => returnVal.push({ name: hideModel.name, visible: false }));
-            return returnVal;
-        });
-    }
-    /**
-     * Create a clone of an existing model.\
-     * Only the geometry (meshes, transform nodes) gets cloned, as materials are typically shared across the whole scene.
-     *
-     * @param show show model immediately after cloning
-     * @param options additional options for the cloning procedure, like renaming algorithms
-     */
-    cloneModel(name, newModelName, show = true, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sourceModel = this._getModel(name);
-            if (!sourceModel) {
-                throw new index_1.ViewerError({
-                    id: index_1.ViewerErrorIds.ModelNotRegistered,
-                    message: `Can't clone model "${name}" as model is not registered`,
-                });
-            }
-            const existingModel = this._getModel(newModelName);
-            if (existingModel) {
-                throw new index_1.ViewerError({
-                    id: index_1.ViewerErrorIds.ModelAlreadyExists,
-                    message: `Can't create clone as model "${newModelName}" already exists`,
-                });
-            }
-            if (sourceModel.state === 'notLoaded') {
-                yield this._loadModel(sourceModel);
-            }
-            else if (sourceModel.state === 'loading') {
-                yield this._loadModelPromises[sourceModel.name];
-            }
-            const clonedModel = {
-                name: newModelName,
-                url: sourceModel.url,
-                state: 'loaded',
-                assetContainer: (0, cloning_helper_1.cloneModelAssetContainer)(sourceModel.assetContainer, newModelName, {
-                    nodeNamingStrategy: options === null || options === void 0 ? void 0 : options.nodeNamingStrategy,
-                    tagNamingStrategy: options === null || options === void 0 ? void 0 : options.tagNamingStrategy,
-                }, this.viewer.scene),
-                isClone: true,
-            };
-            this._modelAssets[newModelName] = clonedModel;
-            if (show) {
-                yield this._showModel(clonedModel);
-            }
-        });
-    }
-    /**
-     * Removes a cloned model from the scene and from the internal model storage.\
-     * Deleted clones can not be shown again.
-     */
-    deleteClonedModel(name) {
-        const model = this._getModel(name);
-        if (!model) {
-            throw new index_1.ViewerError({
-                id: index_1.ViewerErrorIds.ModelNotRegistered,
-                message: `Can't delete cloned model "${name}" as model is not registered`,
-            });
-        }
-        if (!model.isClone) {
-            throw new index_1.ViewerError({
-                id: index_1.ViewerErrorIds.ModelIsNotAClone,
-                message: `Can't delete model "${name}" as model is not a clone`,
-            });
-        }
-        model.assetContainer.dispose();
-        delete this._modelAssets[name];
-    }
-    /**
-     * Removes all cloned models from the scene and the internal model storage.
-     */
-    deleteAllClonedModels() {
-        const clonedModelNames = Object.values(this._modelAssets)
-            .filter(model => model.isClone)
-            .map(model => model.name);
-        clonedModelNames.forEach(modelName => this.deleteClonedModel(modelName));
-    }
-    /**
-     * Loads and returns the asset container of a certain model.\
-     * This can be used to access the models content without having to add it to the scene.\
-     * A typical use case is to clone or instantiate a node from a "library" model.
-     */
-    getAssetContainerOfModel(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const model = this._getModel(name);
-            if (!model) {
-                throw new index_1.ViewerError({
-                    id: index_1.ViewerErrorIds.ModelNotRegistered,
-                    message: `Can't get asset container of model "${name}" as model is not registered`,
-                });
-            }
-            if (model.state === 'notLoaded') {
-                yield this._loadModel(model);
-            }
-            else if (model.state === 'loading') {
-                yield this._loadModelPromises[model.name];
-            }
-            if (model.state !== 'inScene') {
-                yield this._prepareModelForScene(model);
-            }
-            return model.assetContainer;
-        });
-    }
-    /**
-     * Get model by name
-     */
-    _getModel(name) {
-        if (name === '$fallback') {
-            return this._fallbackModelAsset;
-        }
-        const replacedName = ModelManager._replaceSlashes(name);
-        const model = this._modelAssets[replacedName];
-        return model;
-    }
-    /**
-     * Load model into scene, but don't show it immediately
-     */
-    _loadModel(model) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const loadModelPromise = () => __awaiter(this, void 0, void 0, function* () {
-                model.state = 'loading';
-                const curEnvTexture = this.viewer.scene.environmentTexture;
-                const curEnvIntensity = this.viewer.scene.environmentIntensity;
-                let assetContainer;
-                try {
-                    assetContainer = yield index_1.SceneLoader.LoadAssetContainerAsync('', model.url, this.viewer.scene);
-                }
-                catch (e) {
-                    throw new index_1.ViewerError({
-                        id: index_1.ViewerErrorIds.AssetLoadingFailed,
-                        message: `Error loading model "${model.name}" from url "${model.url}":\n${e.message}`,
-                    });
-                }
-                // remove all lights and cameras from the asset, as this data should be handled globally in the scene instead of
-                // being in a model context
-                [...assetContainer.lights].forEach(light => light.dispose());
-                [...assetContainer.cameras].forEach(camera => camera.dispose());
-                // environment texture and intensity has been overwritten by load asset container function
-                this.viewer.scene.environmentTexture = curEnvTexture;
-                this.viewer.scene.environmentIntensity = curEnvIntensity;
-                model.assetContainer = assetContainer;
-                model.state = 'loaded';
-                delete this._loadModelPromises[model.name];
-            });
-            this._loadModelPromises[model.name] = loadModelPromise();
-            return this._loadModelPromises[model.name];
-        });
-    }
-    /**
-     * Apply parameter to the model in the asset container.
-     * This is typically done before the model is added to the scene to avoid changes on the visible model, which ensures
-     * a smooth model switch behaviour.
-     */
-    _prepareModelForScene(model) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.viewer.parameterManager.applyAllParameterValuesToModel(model.assetContainer);
-            // parameter manager did his job, now apply the deferred materials to all meshes that are not explicitely hidden by
-            // the parameter manager
-            yield this._applyDeferredMaterialsForAllVisibleMeshes(model);
-        });
-    }
-    /**
-     * Add assets of asset container to scene, do the scene preparation if required.
-     * CAUTION: model is expected to be in the correct loading state already.
-     *
-     * @param skipPreparation optionally skip applying parameter values to model before showing it
-     *                        (see {@link _prepareModelForScene})
-     */
-    _showModel(model, skipPreparation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!skipPreparation) {
-                yield this._prepareModelForScene(model);
-            }
-            model.assetContainer.addToScene();
-            model.state = 'inScene';
-        });
-    }
-    /**
-     * Remove assets of asset container from scene
-     */
-    _hideModel(model) {
-        model.assetContainer.removeFromScene();
-        model.state = 'loaded';
-    }
-    /**
-     * Creates and assigns each "deferred" material to the corresponding mesh, if the mesh is visible.
-     * Model should be ready to use immediately after this function has done it's job.
-     */
-    _applyDeferredMaterialsForAllVisibleMeshes(model) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const mesh of model.assetContainer.meshes) {
-                const deferredMaterial = (0, metadata_helper_1.getInternalMetadataValue)(mesh, 'deferredMaterial');
-                const rawVisibleValue = this.viewer.parameterManager.getParameterValueOfNode(mesh, index_1.BuiltInParameter.Visible);
-                const visible = rawVisibleValue === undefined || index_1.ParameterManager.parseBoolean(rawVisibleValue) === true;
-                if (deferredMaterial && visible) {
-                    yield this.viewer.materialManager.setMaterialOnMesh(deferredMaterial, mesh);
-                }
-            }
-        });
-    }
-}
-exports.ModelManager = ModelManager;
-/**
- * CAUTION: this has to be in sync with the Combeenation backend!
- * @internal
- */
-ModelManager.CBN_FALLBACK_MODEL_ASSET_NAME = '$fallback';
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelManager = void 0;
+const index_1 = require("../index");
+const cloning_helper_1 = require("../internal/cloning-helper");
+const metadata_helper_1 = require("../internal/metadata-helper");
+const lodash_es_1 = require("lodash-es");
+/**
+ * Manager for handling 3d models.\
+ * Responsible for loading models and handling their visibility.\
+ * Also contains advanced features like model cloning.
+ */
+class ModelManager {
+    constructor(viewer) {
+        this.viewer = viewer;
+        this._modelAssets = {};
+        this._fallbackModelAsset = {
+            name: ModelManager.CBN_FALLBACK_MODEL_ASSET_NAME,
+            url: '',
+            state: 'loaded',
+            assetContainer: new index_1.AssetContainer(),
+            isClone: false,
+        };
+        this._loadModelPromises = {};
+    }
+    get modelNames() {
+        return Object.keys(this._modelAssets);
+    }
+    /**
+     * Nested models were targeted with slash notation previously, as Spec couldn't work with dots.
+     * Dots were interpreted as inherited model.
+     * Now the Hive viewer parameters are returning slash notated asset names, whereas the asset names from the
+     * prepacked asset manager are dot notated.
+     * This function converts slash to dot notation, so that models can be target with slash and dot notation alike.
+     */
+    static _replaceSlashes(inputStr) {
+        return inputStr.split('/').join('.');
+    }
+    /**
+     * Creates content for the fallback model, which is actually just a black cube.
+     * This is used for 3d assets that are linked in a data source but not available (yet).
+     * The Combeenation backend exchanges the missing 3d asset name with "$fallback", which indicates that we shouldn't
+     * throw an error but just show the fallback model instead.
+     *
+     * @internal
+     */
+    createFallbackModel() {
+        const fallbackCube = index_1.MeshBuilder.CreateBox('$fallbackCube', { size: 1 }, this.viewer.scene);
+        fallbackCube._parentContainer = this._fallbackModelAsset.assetContainer;
+        this._fallbackModelAsset.assetContainer.meshes.push(fallbackCube);
+        // NOTE: this is theoretically async, but in reality it's not when getting the material description from the CBN
+        // server
+        // also this is just a fallback that shouldn't be relevant in productive configurators
+        this.viewer.materialManager.setMaterialOnMesh(index_1.MaterialManager.CBN_FALLBACK_MATERIAL_NAME, fallbackCube);
+        this._fallbackModelAsset.assetContainer.removeFromScene();
+    }
+    /**
+     * Register models for 3d viewer, this is required for each model before it can be loaded/shown.\
+     * The "viewer control" inside the Combeenation framework calls this function automatically with all assigned
+     * 3d assets.
+     */
+    registerModels(modelAssets) {
+        for (const { name, url } of modelAssets) {
+            const existingModel = this._modelAssets[name];
+            if (existingModel) {
+                console.warn(`Model ${name} is already registered`);
+                return;
+            }
+            const model = { name, url, state: 'notLoaded', assetContainer: new index_1.AssetContainer(), isClone: false };
+            this._modelAssets[name] = model;
+        }
+    }
+    /**
+     * Loads the model and all it's assigned materials.\
+     * This function should be used for "eager loading" of models, so that model switching will be instant in the
+     * process.\
+     * If you don't plan to do this, just use {@link setModelVisibility} as this function will load the model under the
+     * hood the first time the model gets visible.
+     */
+    loadModel(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = this._getModel(name);
+            if (!model) {
+                throw new index_1.ViewerError({
+                    id: index_1.ViewerErrorIds.ModelNotRegistered,
+                    message: `Can't load model "${name}" as model is not registered`,
+                });
+            }
+            if (model.state !== 'notLoaded') {
+                console.warn(`Model ${name} is already loaded or currently loading`);
+                return;
+            }
+            yield this._loadModel(model);
+            yield this._prepareModelForScene(model);
+        });
+    }
+    /**
+     * Enables/disables multiple one or multiple models simultaniously.\
+     * All required models are loaded before adjusting the visibility to avoid flashing in the 3d scene.
+     *
+     * @returns Array of changed visibility status, combined with the corresponding model name
+     */
+    setModelVisibility(modelVisibility) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const showModels = [];
+            const hideModels = [];
+            if (!(0, lodash_es_1.isArray)(modelVisibility)) {
+                modelVisibility = [modelVisibility];
+            }
+            for (const entry of modelVisibility) {
+                const model = this._getModel(entry.name);
+                if (!model) {
+                    throw new index_1.ViewerError({
+                        id: index_1.ViewerErrorIds.ModelNotRegistered,
+                        message: `Can't set visibility of model "${entry.name}" as model is not registered`,
+                    });
+                }
+                // there can be multiple "setModelVisibility" calls while the model is loading
+                // loading can be awaited, but it has to be ensured, that the last call of "setModelVisibility" has priority
+                // therefore we store the id of the call in the model
+                const curVisibilityCallId = ((_a = model.visibilityCallId) !== null && _a !== void 0 ? _a : 0) + 1;
+                model.visibilityCallId = curVisibilityCallId;
+                if (entry.visible) {
+                    if (model.state === 'notLoaded') {
+                        yield this._loadModel(model);
+                        // check if this is still the latest visibility call
+                        if (model.visibilityCallId === curVisibilityCallId) {
+                            showModels.push(model);
+                        }
+                    }
+                    else if (model.state === 'loading') {
+                        yield this._loadModelPromises[model.name];
+                        if (model.visibilityCallId === curVisibilityCallId) {
+                            showModels.push(model);
+                        }
+                    }
+                    else if (model.state === 'loaded') {
+                        showModels.push(model);
+                    }
+                }
+                else {
+                    if (model.state === 'loading') {
+                        yield this._loadModelPromises[model.name];
+                        if (model.visibilityCallId === curVisibilityCallId) {
+                            hideModels.push(model);
+                        }
+                    }
+                    else if (model.state === 'inScene') {
+                        hideModels.push(model);
+                    }
+                }
+            }
+            for (const showModel of showModels) {
+                yield this._prepareModelForScene(showModel);
+            }
+            for (const showModel of showModels) {
+                yield this._showModel(showModel, true);
+            }
+            for (const hideModel of hideModels) {
+                this._hideModel(hideModel);
+            }
+            const returnVal = [];
+            showModels.forEach(showModel => returnVal.push({ name: showModel.name, visible: true }));
+            hideModels.forEach(hideModel => returnVal.push({ name: hideModel.name, visible: false }));
+            return returnVal;
+        });
+    }
+    /**
+     * Create a clone of an existing model.\
+     * Only the geometry (meshes, transform nodes) gets cloned, as materials are typically shared across the whole scene.
+     *
+     * @param show show model immediately after cloning
+     * @param options additional options for the cloning procedure, like renaming algorithms
+     */
+    cloneModel(name, newModelName, show = true, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sourceModel = this._getModel(name);
+            if (!sourceModel) {
+                throw new index_1.ViewerError({
+                    id: index_1.ViewerErrorIds.ModelNotRegistered,
+                    message: `Can't clone model "${name}" as model is not registered`,
+                });
+            }
+            const existingModel = this._getModel(newModelName);
+            if (existingModel) {
+                throw new index_1.ViewerError({
+                    id: index_1.ViewerErrorIds.ModelAlreadyExists,
+                    message: `Can't create clone as model "${newModelName}" already exists`,
+                });
+            }
+            if (sourceModel.state === 'notLoaded') {
+                yield this._loadModel(sourceModel);
+            }
+            else if (sourceModel.state === 'loading') {
+                yield this._loadModelPromises[sourceModel.name];
+            }
+            const clonedModel = {
+                name: newModelName,
+                url: sourceModel.url,
+                state: 'loaded',
+                assetContainer: (0, cloning_helper_1.cloneModelAssetContainer)(sourceModel.assetContainer, newModelName, {
+                    nodeNamingStrategy: options === null || options === void 0 ? void 0 : options.nodeNamingStrategy,
+                    tagNamingStrategy: options === null || options === void 0 ? void 0 : options.tagNamingStrategy,
+                }, this.viewer.scene),
+                isClone: true,
+            };
+            this._modelAssets[newModelName] = clonedModel;
+            if (show) {
+                yield this._showModel(clonedModel);
+            }
+        });
+    }
+    /**
+     * Removes a cloned model from the scene and from the internal model storage.\
+     * Deleted clones can not be shown again.
+     */
+    deleteClonedModel(name) {
+        const model = this._getModel(name);
+        if (!model) {
+            throw new index_1.ViewerError({
+                id: index_1.ViewerErrorIds.ModelNotRegistered,
+                message: `Can't delete cloned model "${name}" as model is not registered`,
+            });
+        }
+        if (!model.isClone) {
+            throw new index_1.ViewerError({
+                id: index_1.ViewerErrorIds.ModelIsNotAClone,
+                message: `Can't delete model "${name}" as model is not a clone`,
+            });
+        }
+        model.assetContainer.dispose();
+        delete this._modelAssets[name];
+    }
+    /**
+     * Removes all cloned models from the scene and the internal model storage.
+     */
+    deleteAllClonedModels() {
+        const clonedModelNames = Object.values(this._modelAssets)
+            .filter(model => model.isClone)
+            .map(model => model.name);
+        clonedModelNames.forEach(modelName => this.deleteClonedModel(modelName));
+    }
+    /**
+     * Loads and returns the asset container of a certain model.\
+     * This can be used to access the models content without having to add it to the scene.\
+     * A typical use case is to clone or instantiate a node from a "library" model.
+     */
+    getAssetContainerOfModel(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = this._getModel(name);
+            if (!model) {
+                throw new index_1.ViewerError({
+                    id: index_1.ViewerErrorIds.ModelNotRegistered,
+                    message: `Can't get asset container of model "${name}" as model is not registered`,
+                });
+            }
+            if (model.state === 'notLoaded') {
+                yield this._loadModel(model);
+            }
+            else if (model.state === 'loading') {
+                yield this._loadModelPromises[model.name];
+            }
+            if (model.state !== 'inScene') {
+                yield this._prepareModelForScene(model);
+            }
+            return model.assetContainer;
+        });
+    }
+    /**
+     * Get model by name
+     */
+    _getModel(name) {
+        if (name === '$fallback') {
+            return this._fallbackModelAsset;
+        }
+        const replacedName = ModelManager._replaceSlashes(name);
+        const model = this._modelAssets[replacedName];
+        return model;
+    }
+    /**
+     * Load model into scene, but don't show it immediately
+     */
+    _loadModel(model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const loadModelPromise = () => __awaiter(this, void 0, void 0, function* () {
+                model.state = 'loading';
+                const curEnvTexture = this.viewer.scene.environmentTexture;
+                const curEnvIntensity = this.viewer.scene.environmentIntensity;
+                let assetContainer;
+                try {
+                    assetContainer = yield index_1.SceneLoader.LoadAssetContainerAsync('', model.url, this.viewer.scene);
+                }
+                catch (e) {
+                    throw new index_1.ViewerError({
+                        id: index_1.ViewerErrorIds.AssetLoadingFailed,
+                        message: `Error loading model "${model.name}" from url "${model.url}":\n${e.message}`,
+                    });
+                }
+                // remove all lights and cameras from the asset, as this data should be handled globally in the scene instead of
+                // being in a model context
+                [...assetContainer.lights].forEach(light => light.dispose());
+                [...assetContainer.cameras].forEach(camera => camera.dispose());
+                // environment texture and intensity has been overwritten by load asset container function
+                this.viewer.scene.environmentTexture = curEnvTexture;
+                this.viewer.scene.environmentIntensity = curEnvIntensity;
+                model.assetContainer = assetContainer;
+                model.state = 'loaded';
+                delete this._loadModelPromises[model.name];
+            });
+            this._loadModelPromises[model.name] = loadModelPromise();
+            return this._loadModelPromises[model.name];
+        });
+    }
+    /**
+     * Apply parameter to the model in the asset container.
+     * This is typically done before the model is added to the scene to avoid changes on the visible model, which ensures
+     * a smooth model switch behaviour.
+     */
+    _prepareModelForScene(model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.viewer.parameterManager.applyAllParameterValuesToModel(model.assetContainer);
+            // parameter manager did his job, now apply the deferred materials to all meshes that are not explicitely hidden by
+            // the parameter manager
+            yield this._applyDeferredMaterialsForAllVisibleMeshes(model);
+        });
+    }
+    /**
+     * Add assets of asset container to scene, do the scene preparation if required.
+     * CAUTION: model is expected to be in the correct loading state already.
+     *
+     * @param skipPreparation optionally skip applying parameter values to model before showing it
+     *                        (see {@link _prepareModelForScene})
+     */
+    _showModel(model, skipPreparation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!skipPreparation) {
+                yield this._prepareModelForScene(model);
+            }
+            model.assetContainer.addToScene();
+            model.state = 'inScene';
+        });
+    }
+    /**
+     * Remove assets of asset container from scene
+     */
+    _hideModel(model) {
+        model.assetContainer.removeFromScene();
+        model.state = 'loaded';
+    }
+    /**
+     * Creates and assigns each "deferred" material to the corresponding mesh, if the mesh is visible.
+     * Model should be ready to use immediately after this function has done it's job.
+     */
+    _applyDeferredMaterialsForAllVisibleMeshes(model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const mesh of model.assetContainer.meshes) {
+                const deferredMaterial = (0, metadata_helper_1.getInternalMetadataValue)(mesh, 'deferredMaterial');
+                const rawVisibleValue = this.viewer.parameterManager.getParameterValueOfNode(mesh, index_1.BuiltInParameter.Visible);
+                const visible = rawVisibleValue === undefined || index_1.ParameterManager.parseBoolean(rawVisibleValue) === true;
+                if (deferredMaterial && visible) {
+                    yield this.viewer.materialManager.setMaterialOnMesh(deferredMaterial, mesh);
+                }
+            }
+        });
+    }
+}
+exports.ModelManager = ModelManager;
+/**
+ * CAUTION: this has to be in sync with the Combeenation backend!
+ * @internal
+ */
+ModelManager.CBN_FALLBACK_MODEL_ASSET_NAME = '$fallback';
 //# sourceMappingURL=model-manager.js.map