@combeenation/3d-viewer 5.1.2 → 5.2.0-alpha1

package/dist/lib-es6/{api → src/api}/util/babylonHelper.js

@@ -1,582 +1,562 @@
-import { __spreadArrays } from "tslib";
-import { PhotoDome } from '@babylonjs/core/Helpers/photoDome';
-import { Light } from '@babylonjs/core/Lights/light';
-import { CubeTexture } from '@babylonjs/core/Materials/Textures/cubeTexture';
-import { Axis } from '@babylonjs/core/Maths/math.axis';
-import { Color3, Color4 } from '@babylonjs/core/Maths/math.color';
-import { Quaternion, Vector3 } from '@babylonjs/core/Maths/math.vector';
-import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
-import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh';
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import { Tools } from '@babylonjs/core/Misc/tools';
-import { defaultEnvHelperColor, defaultSceneClearColor } from '../internal/sceneSetup';
-import { cloneDeep, get, has, merge } from 'lodash-es';
-import { DottedPath } from '../classes/dottedPath';
-import { addMissingMaterialObserver, missingMaterialMetadataName } from './sceneLoaderHelper';
-var backgroundDomeName = 'BackgroundDome_ViewerGenerated';
-var envHelperMetadataName = 'viewerEnvHelper';
-/**
- * @param node
- * @return Node
- */
-var getRootNode = function (node) {
-    var _node = node;
-    while (_node.parent) {
-        _node = _node.parent;
-    }
-    return _node;
-};
-/**
- * @param nodes
- * @param predicate
- * @return Map<DottedPath, T>
- */
-var mapToDottedNodes = function (nodes, predicate) {
-    var map = new Map();
-    var addNodes = function (_node) {
-        if (predicate && predicate(_node)) {
-            map.set(_node.metadata.dottedPath, _node);
-        }
-        _node.getChildren().forEach(function (child) {
-            addNodes(child);
-        });
-    };
-    nodes.forEach(function (node) {
-        addNodes(node);
-    });
-    return map;
-};
-/**
- * @param node
- * @return DottedPath
- */
-var getDottedPathForNode = function (node) {
-    var dottedPath = DottedPath.create(node.name);
-    var _parent = node;
-    while (_parent.parent) {
-        _parent = _parent.parent;
-        dottedPath.unshiftPart(_parent.name);
-    }
-    return dottedPath;
-};
-/**
- * @param node
- * @param predicate
- * @param deep
- * @return TransformNode | null
- */
-var cloneTransformNode = function (node, predicate, deep) {
-    if (deep === void 0) { deep = true; }
-    if (predicate && !predicate(node)) {
-        return null;
-    }
-    var clone = node.clone(node.name, node.parent, true);
-    if (clone) {
-        clone.metadata = cloneDeep(node.metadata);
-        // if the cloned node is of type InstancedMesh, due to a bug(?),
-        // the InstancedMesh.isEnabled state may have changed after cloning.
-        // in that case, set the clone's enabled state to the original's state
-        if (node.constructor.name === 'InstancedMesh') {
-            clone.setEnabled(node.isEnabled(false));
-        }
-    }
-    if (deep) {
-        var children = node.getChildTransformNodes(true);
-        children.forEach(function (child) {
-            var clonedChild = cloneTransformNode(child, predicate, deep);
-            if (clonedChild) {
-                clonedChild.parent = clone;
-            }
-        });
-    }
-    return clone;
-};
-/**
- * @param node
- */
-var cloneNodeWithParents = function (node) {
-    var clone = null;
-    if (node instanceof TransformNode) {
-        clone = node.clone(node.name, cloneNodeWithParents(node.parent), true);
-    }
-    else if (node instanceof Light) {
-        clone = node.clone(node.name, cloneNodeWithParents(node.parent));
-    }
-    else if (node) {
-        throw new Error("Cloning of \"" + (node === null || node === void 0 ? void 0 : node.constructor.name) + "\" is not implemented (yet).");
-    }
-    return clone;
-};
-/**
- * @param node
- * @param deep
- * @param prefix
- * @return TransformNode
- */
-var cloneTransformNodeMaterial = function (node, prefix, deep) {
-    if (prefix === void 0) { prefix = ''; }
-    if (deep === void 0) { deep = true; }
-    if (node instanceof AbstractMesh && node.material) {
-        var newMatName = DottedPath.create(prefix).addParts([node.material.name, 'clone', node.uniqueId.toString()]);
-        node.material = node.material.clone(newMatName.path);
-    }
-    if (deep) {
-        var children = node.getChildTransformNodes(true);
-        children.forEach(function (child) { return cloneTransformNodeMaterial(child, prefix, deep); });
-    }
-    return node;
-};
-/**
- * @param node
- * @param deep
- * @param metadata
- */
-var injectNodeMetadata = function (node, metadata, deep) {
-    if (deep === void 0) { deep = true; }
-    node.metadata = merge({}, node.metadata, metadata);
-    if (deep && node instanceof TransformNode) {
-        var children = node.getChildTransformNodes(true);
-        children.forEach(function (child) { return injectNodeMetadata(child, metadata, deep); });
-    }
-};
-/**
- * @param node
- * @param assertCallable
- * @param callableParameters
- * @param deep
- */
-var assertTransformNode = function (node, assertCallable, callableParameters, deep) {
-    if (callableParameters === void 0) { callableParameters = []; }
-    if (deep === void 0) { deep = true; }
-    assertCallable.apply(void 0, __spreadArrays([node], callableParameters));
-    if (deep) {
-        var children = node.getChildTransformNodes(true);
-        children.forEach(function (child) { return assertTransformNode(child, assertCallable, callableParameters, deep); });
-    }
-};
-/**
- * @param node
- * @param deep
- */
-var activateTransformNode = function (node, deep) {
-    if (deep === void 0) { deep = true; }
-    node.setEnabled(true);
-    /*
-      if( node instanceof AbstractMesh ) {
-          node.visibility = 1;
-          node.isPickable = true;
-      }
-      */
-    if (deep) {
-        node.getChildTransformNodes(true).forEach(function (child) { return activateTransformNode(child, deep); });
-    }
-};
-/**
- * @param node
- * @param deep
- */
-var deactivateTransformNode = function (node, deep) {
-    if (deep === void 0) { deep = true; }
-    node.setEnabled(false);
-    /*
-      if( node instanceof AbstractMesh ) {
-          node.visibility = 0;
-          node.isPickable = false;
-      }
-      */
-    if (deep) {
-        node.getChildTransformNodes(true).forEach(function (child) { return deactivateTransformNode(child, deep); });
-    }
-};
-/**
- * @param node
- */
-var enableNodeWithParents = function (node) {
-    node.setEnabled(true);
-    if (node.parent) {
-        enableNodeWithParents(node.parent);
-    }
-};
-/**
- * @param node
- */
-var disableNodeWithParents = function (node) {
-    node.setEnabled(false);
-    if (node.parent) {
-        disableNodeWithParents(node.parent);
-    }
-};
-/**
- * Applies a {@link TransformationDefinition} consecutively to ensure dependencies in positioning etc.
- * @param node
- * @param transformation
- */
-var transformTransformNode = function (node, transformation) {
-    // scaling
-    if (!has(node.metadata, 'scaling.initial')) {
-        injectNodeMetadata(node, { 'scaling.initial': node.scaling }, false);
-    }
-    var initialScaling = get(node.metadata, 'scaling.initial');
-    node.scaling = initialScaling.multiply(transformation.scaling);
-    // position
-    if (!has(node.metadata, 'position.initial')) {
-        injectNodeMetadata(node, { 'position.initial': node.absolutePosition.clone() }, false);
-    }
-    var initialPosition = get(node.metadata, 'position.initial');
-    node.setAbsolutePosition(initialPosition.add(transformation.position).multiply(transformation.scaling));
-    // rotation
-    if (!has(node.metadata, 'rotation.initial')) {
-        var rotationQuaternion = node.rotationQuaternion;
-        if (!rotationQuaternion) {
-            rotationQuaternion = Quaternion.RotationYawPitchRoll(node.rotation.x, node.rotation.y, node.rotation.z);
-        }
-        injectNodeMetadata(node, { 'rotation.initial': rotationQuaternion.asArray() }, false);
-    }
-    var initialRotationQuaternion = Quaternion.FromArray(get(node.metadata, 'rotation.initial'));
-    node.rotationQuaternion = initialRotationQuaternion;
-    node.rotateAround(Vector3.Zero(), Axis.X, transformation.rotation.x);
-    node.rotateAround(Vector3.Zero(), Axis.Y, transformation.rotation.y);
-    node.rotateAround(Vector3.Zero(), Axis.Z, transformation.rotation.z);
-    node.computeWorldMatrix(true);
-};
-/**
- * Apply changes of environment (background texture, etc.) consecutively in order to avoid dependency related issues.
- * @param scene
- * @param envDef
- */
-var changeEnvironment = function (scene, envDef) {
-    var _a;
-    var _b, _c;
-    // issue warning if both background texture and usedefault are set
-    if (envDef.environmentUseDefault && envDef.environmentBackground) {
-        console.warn("!!! Warning !!! Spec parameter 'environment.usedefault' is being overruled by 'environment.background'.");
-    }
-    var useDefaultEnv = envDef.environmentUseDefault && !envDef.environmentBackground;
-    // 1) set ENVIRONMENT_COLOR
-    var clearColorBefore = scene.clearColor.toString();
-    scene.clearColor = envDef.environmentColor
-        ? Color4.FromColor3(envDef.environmentColor)
-        : useDefaultEnv
-            ? defaultEnvHelperColor
-            : defaultSceneClearColor;
-    var clearColorChanged = clearColorBefore !== scene.clearColor.toString();
-    // Remove all URI params from given env URL as `CubeTexture.CreateFromPrefilteredData` does not work correctly with
-    // URLs which contain URI params.
-    // E.g. `https://some.url/.../studio.env?name=defaultEnv` throws an exception whilst `https://some.url/.../studio.env`
-    // works as expected.
-    //
-    // See BJS forum for more details:
-    // https://forum.babylonjs.com/t/cubetexture-createfromprefiltereddata-does-not-work-with-url-that-contains-uri-params/34097
-    var newEnvUrl = (_b = envDef.environment) === null || _b === void 0 ? void 0 : _b.split('?')[0];
-    // 2) dispose existing & set new ENVIRONMENT (==texture)
-    var curEnvTexture = scene.environmentTexture;
-    var envTextureChanged = newEnvUrl !== (curEnvTexture === null || curEnvTexture === void 0 ? void 0 : curEnvTexture.url);
-    if (curEnvTexture && (!newEnvUrl || envTextureChanged)) {
-        curEnvTexture.dispose();
-    }
-    var rotation = envDef.environmentRotation !== undefined ? Tools.ToRadians(envDef.environmentRotation) : 0;
-    if (newEnvUrl && envTextureChanged) {
-        var envTexture = CubeTexture.CreateFromPrefilteredData(newEnvUrl, scene);
-        envTexture.rotationY = rotation;
-        scene.environmentTexture = envTexture;
-    }
-    else if (curEnvTexture && curEnvTexture.rotationY !== rotation) {
-        curEnvTexture.rotationY = rotation;
-    }
-    // 3) dispose existing & set new ENVIRONMENT_BACKGROUND
-    var curDome = scene.getNodeByName(backgroundDomeName);
-    var backgroundUrlChanged = envDef.environmentBackground !== (curDome === null || curDome === void 0 ? void 0 : curDome.texture.url);
-    if (curDome && (!envDef.environmentBackground || backgroundUrlChanged)) {
-        curDome.dispose();
-    }
-    var rotationPhotoDome = -1 * rotation;
-    if (envDef.environmentBackground && backgroundUrlChanged) {
-        var textureUrl = envDef.environmentBackground;
-        var dome = new PhotoDome(backgroundDomeName, textureUrl, { resolution: 32, size: 450 }, scene);
-        // Rotate submesh to get them in line with environment texture
-        dome.getChildMeshes(true)[0].rotation.y = Tools.ToRadians(90);
-        dome.rotation.y = rotationPhotoDome;
-    }
-    else if (curDome && curDome.rotation.y !== rotationPhotoDome) {
-        curDome.rotation.y = rotationPhotoDome;
-    }
-    // 4) dispose existing & set new ENVIRONMENT_USEDEFAULT (only if no background is set)
-    var curEnvHelper = (_c = scene.metadata) === null || _c === void 0 ? void 0 : _c[envHelperMetadataName];
-    if (curEnvHelper && !useDefaultEnv) {
-        curEnvHelper.dispose();
-        delete scene.metadata[envHelperMetadataName];
-    }
-    var envHelperMainColor = Color3.FromArray(scene.clearColor.asArray());
-    if (useDefaultEnv && !curEnvHelper) {
-        var envHelper = scene.createDefaultEnvironment({ sizeAuto: true });
-        envHelper === null || envHelper === void 0 ? void 0 : envHelper.setMainColor(envHelperMainColor);
-        if (envHelper) {
-            scene.metadata = merge({}, scene.metadata, (_a = {}, _a[envHelperMetadataName] = envHelper, _a));
-        }
-    }
-    else if (curEnvHelper && useDefaultEnv && clearColorChanged) {
-        curEnvHelper.setMainColor(envHelperMainColor);
-    }
-    // 5) set ENVIRONMENT_INTENSITY
-    if (envDef.environmentIntensity !== undefined) {
-        scene.environmentIntensity = envDef.environmentIntensity;
-    }
-};
-/**
- * @param node
- * @param materialName
- * @param deep
- */
-var setMaterial = function (variant, node, materialName, deep) {
-    var _a;
-    if (deep === void 0) { deep = true; }
-    if (node instanceof AbstractMesh) {
-        var hasMissingMaterial = has(node.metadata, missingMaterialMetadataName);
-        if (node.isEnabled()) {
-            node.material = variant.getMaterial(materialName);
-            if (hasMissingMaterial) {
-                delete node.metadata[missingMaterialMetadataName];
-            }
-        }
-        else {
-            injectNodeMetadata(node, (_a = {}, _a[missingMaterialMetadataName] = materialName, _a), false);
-            // If it already had the missing material flag before, there already exists an observer...
-            if (!hasMissingMaterial) {
-                addMissingMaterialObserver(node);
-            }
-        }
-    }
-    if (deep) {
-        node.getChildTransformNodes(true).forEach(function (child) { return setMaterial(variant, child, materialName, deep); });
-    }
-};
-/**
- * !!! Warning !!!
- * This function is not public API. Whilst it can help solving certain problems, it only works reliably in well defined
- * situations and can cause unwanted side effects under some conditions. Use carefully at your own risk!
- *
- * See https://combeenation.myjetbrains.com/youtrack/issue/CB-5906 for further details regarding this warning.
- *
- * Set material of an instanced meshes source mesh.
- * Changes the material of all instanced meshes which have the same source mesh.
- *
- * @param node
- * @param material
- * @param deep
- *
- * @ignore
- */
-var setSourceNodeMaterial = function (node, material, deep) {
-    if (deep === void 0) { deep = true; }
-    var warn = "\tYou're using \"setSourceNodeMaterial\" which is not public API.\n\tWhilst it can help solving certain problems, it only works reliably in well defined situations and can cause unwanted side effects under some conditions.\n\tUse carefully at your own risk!";
-    console.warn("!!! Warning !!!\n" + warn);
-    if (node instanceof InstancedMesh) {
-        node.sourceMesh.material = material;
-    }
-    if (deep) {
-        node.getChildTransformNodes(true).forEach(function (child) { return setSourceNodeMaterial(child, material, deep); });
-    }
-};
-/**
- * @param node
- * @param color
- * @param deep
- */
-var setMaterialColor = function (node, color, deep) {
-    if (deep === void 0) { deep = true; }
-    if (node instanceof AbstractMesh && node.material) {
-        var materialCls = node.material.getClassName();
-        switch (materialCls) {
-            case 'PBRMaterial':
-                node.material.albedoColor = color.toLinearSpace();
-                break;
-            case 'StandardMaterial':
-                node.material.diffuseColor = color;
-                break;
-            default:
-                throw new Error("Setting color for material of instance \"" + materialCls + "\" not implemented (yet).");
-        }
-    }
-    if (deep) {
-        node.getChildTransformNodes(true).forEach(function (child) { return setMaterialColor(child, color, deep); });
-    }
-};
-/**
- * @param node
- * @param texture
- * @param deep
- */
-var setMaterialTexture = function (node, texture, deep) {
-    if (deep === void 0) { deep = true; }
-    if (node instanceof AbstractMesh && node.material) {
-        var materialCls = node.material.getClassName();
-        switch (materialCls) {
-            case 'PBRMaterial':
-                node.material.albedoTexture = texture;
-                break;
-            case 'StandardMaterial':
-                node.material.diffuseTexture = texture;
-                break;
-            default:
-                throw new Error("Setting texture for material of instance \"" + materialCls + "\" not implemented (yet).");
-        }
-    }
-    if (deep) {
-        node.getChildTransformNodes(true).forEach(function (child) { return setMaterialTexture(child, texture, deep); });
-    }
-};
-/**
- * @param node
- * @param metallness
- * @param deep
- */
-var setMaterialMetallness = function (node, metallness, deep) {
-    if (deep === void 0) { deep = true; }
-    if (node instanceof AbstractMesh && node.material) {
-        var materialCls = node.material.getClassName();
-        switch (materialCls) {
-            case 'PBRMaterial':
-                node.material.metallic = metallness;
-                break;
-            default:
-                throw new Error("Setting metallness for material of instance \"" + materialCls + "\" not implemented (yet).");
-        }
-    }
-    if (deep) {
-        node.getChildTransformNodes(true).forEach(function (child) { return setMaterialMetallness(child, metallness, deep); });
-    }
-};
-/**
- * @param node
- * @param roughness
- * @param deep
- */
-var setMaterialRoughness = function (node, roughness, deep) {
-    if (deep === void 0) { deep = true; }
-    if (node instanceof AbstractMesh && node.material) {
-        var materialCls = node.material.getClassName();
-        switch (materialCls) {
-            case 'PBRMaterial':
-                node.material.roughness = roughness;
-                break;
-            case 'StandardMaterial':
-                node.material.roughness = roughness;
-                break;
-            default:
-                throw new Error("Setting roughness for material of instance \"" + materialCls + "\" not implemented (yet).");
-        }
-    }
-    if (deep) {
-        node.getChildTransformNodes(true).forEach(function (child) { return setMaterialRoughness(child, roughness, deep); });
-    }
-};
-/**
- * @param node
- * @param layer
- * @param color
- * @param deep
- */
-var addToHighlightLayer = function (layer, color, node, deep) {
-    if (deep === void 0) { deep = true; }
-    if (node instanceof AbstractMesh) {
-        layer.addMesh(node, color);
-    }
-    if (deep) {
-        node.getChildTransformNodes(true).forEach(function (child) { return addToHighlightLayer(layer, color, child, deep); });
-    }
-};
-/**
- * @param node
- * @param layer
- * @param deep
- */
-var removeFromHighlightLayer = function (layer, node, deep) {
-    if (deep === void 0) { deep = true; }
-    if (node instanceof AbstractMesh) {
-        layer.removeMesh(node);
-    }
-    if (deep) {
-        node.getChildTransformNodes(true).forEach(function (child) { return removeFromHighlightLayer(layer, child, deep); });
-    }
-};
-/**
- * @param node
- * @param receiveShadows
- * @param deep
- */
-var setReceiveShadows = function (node, receiveShadows, deep) {
-    if (deep === void 0) { deep = true; }
-    if (node instanceof AbstractMesh) {
-        node.receiveShadows = receiveShadows;
-    }
-    if (deep) {
-        node.getChildTransformNodes(true).forEach(function (child) { return setReceiveShadows(child, receiveShadows, deep); });
-    }
-};
-/**
- * @param node
- * @param generator
- * @param deep
- */
-var addToShadowGenerator = function (generator, node, deep) {
-    if (deep === void 0) { deep = true; }
-    if (node instanceof AbstractMesh) {
-        // We have to remove the node because there's no duplicate check in babylon
-        generator.removeShadowCaster(node, false);
-        generator.addShadowCaster(node, false);
-    }
-    if (deep) {
-        node.getChildTransformNodes(true).forEach(function (child) { return addToShadowGenerator(generator, child, deep); });
-    }
-};
-/**
- * @param node
- * @param generator
- * @param deep
- */
-var removeFromShadowGenerator = function (generator, node, deep) {
-    if (deep === void 0) { deep = true; }
-    if (node instanceof AbstractMesh) {
-        generator.removeShadowCaster(node, false);
-    }
-    if (deep) {
-        node.getChildTransformNodes(true).forEach(function (child) { return removeFromShadowGenerator(generator, child, deep); });
-    }
-};
-/**
- * https://forum.babylonjs.com/t/get-mesh-bounding-box-position-and-size-in-2d-screen-coordinates/1058/3
- * @param mesh
- * @param scene
- * @param canvas
- */
-var getClientRectFromMesh = function (mesh, scene, canvas) {
-    // get bounding box of the mesh
-    var meshVectors = mesh.getBoundingInfo().boundingBox.vectors;
-    // get the matrix and viewport needed to project the vectors onto the screen
-    var worldMatrix = mesh.getWorldMatrix();
-    var transformMatrix = scene.getTransformMatrix();
-    var viewport = scene.activeCamera.viewport;
-    // loop though all the vectors and project them against the current camera viewport to get a set of coordinates
-    var coordinates = meshVectors.map(function (vector) {
-        var projection = Vector3.Project(vector, worldMatrix, transformMatrix, viewport);
-        projection.x = projection.x * canvas.clientWidth;
-        projection.y = projection.y * canvas.clientHeight;
-        return projection;
-    });
-    // get the min and max for all the coordinates so we can calculate the largest possible screen size
-    var maxX = Math.max.apply(Math, coordinates.map(function (o) { return o.x; }));
-    var minX = Math.min.apply(Math, coordinates.map(function (o) { return o.x; }));
-    var maxY = Math.max.apply(Math, coordinates.map(function (o) { return o.y; }));
-    var minY = Math.min.apply(Math, coordinates.map(function (o) { return o.y; }));
-    // return a ClientRect from this
-    return {
-        width: maxX - minX,
-        height: maxY - minY,
-        left: minX,
-        top: minY,
-        right: maxX,
-        bottom: maxY,
-    };
-};
-export { getRootNode, mapToDottedNodes, getDottedPathForNode, cloneTransformNode, cloneNodeWithParents, cloneTransformNodeMaterial, injectNodeMetadata, assertTransformNode, activateTransformNode, deactivateTransformNode, enableNodeWithParents, disableNodeWithParents, transformTransformNode, setMaterial, setSourceNodeMaterial, setMaterialColor, setMaterialTexture, setMaterialMetallness, setMaterialRoughness, addToHighlightLayer, removeFromHighlightLayer, setReceiveShadows, addToShadowGenerator, removeFromShadowGenerator, getClientRectFromMesh, changeEnvironment, backgroundDomeName, envHelperMetadataName, };
+import { DottedPath } from '../classes/dottedPath';
+import { defaultEnvHelperColor, defaultSceneClearColor } from '../internal/sceneSetup';
+import { addMissingMaterialObserver, missingMaterialMetadataName } from './sceneLoaderHelper';
+import { PhotoDome } from '@babylonjs/core/Helpers/photoDome';
+import { Light } from '@babylonjs/core/Lights/light';
+import { CubeTexture } from '@babylonjs/core/Materials/Textures/cubeTexture';
+import { Axis } from '@babylonjs/core/Maths/math.axis';
+import { Color3, Color4 } from '@babylonjs/core/Maths/math.color';
+import { Quaternion, Vector3 } from '@babylonjs/core/Maths/math.vector';
+import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { Tools } from '@babylonjs/core/Misc/tools';
+import { cloneDeep, get, has, merge } from 'lodash-es';
+const backgroundDomeName = 'BackgroundDome_ViewerGenerated';
+const envHelperMetadataName = 'viewerEnvHelper';
+/**
+ * @param node
+ * @return Node
+ */
+const getRootNode = function (node) {
+    let _node = node;
+    while (_node.parent) {
+        _node = _node.parent;
+    }
+    return _node;
+};
+/**
+ * @param nodes
+ * @param predicate
+ * @return Map<DottedPath, T>
+ */
+const mapToDottedNodes = function (nodes, predicate) {
+    const map = new Map();
+    const addNodes = function (_node) {
+        if (predicate && predicate(_node)) {
+            map.set(_node.metadata.dottedPath, _node);
+        }
+        _node.getChildren().forEach(child => {
+            addNodes(child);
+        });
+    };
+    nodes.forEach(node => {
+        addNodes(node);
+    });
+    return map;
+};
+/**
+ * @param node
+ * @return DottedPath
+ */
+const getDottedPathForNode = function (node) {
+    const dottedPath = DottedPath.create(node.name);
+    let _parent = node;
+    while (_parent.parent) {
+        _parent = _parent.parent;
+        dottedPath.unshiftPart(_parent.name);
+    }
+    return dottedPath;
+};
+/**
+ * @param node
+ * @param predicate
+ * @param deep
+ * @return TransformNode | null
+ */
+const cloneTransformNode = function (node, predicate, deep = true) {
+    if (predicate && !predicate(node)) {
+        return null;
+    }
+    const clone = node.clone(node.name, node.parent, true);
+    if (clone) {
+        clone.metadata = cloneDeep(node.metadata);
+        // if the cloned node is of type InstancedMesh, due to a bug(?),
+        // the InstancedMesh.isEnabled state may have changed after cloning.
+        // in that case, set the clone's enabled state to the original's state
+        if (node.constructor.name === 'InstancedMesh') {
+            clone.setEnabled(node.isEnabled(false));
+        }
+    }
+    if (deep) {
+        const children = node.getChildTransformNodes(true);
+        children.forEach(child => {
+            const clonedChild = cloneTransformNode(child, predicate, deep);
+            if (clonedChild) {
+                clonedChild.parent = clone;
+            }
+        });
+    }
+    return clone;
+};
+/**
+ * @param node
+ */
+const cloneNodeWithParents = function (node) {
+    let clone = null;
+    if (node instanceof TransformNode) {
+        clone = node.clone(node.name, cloneNodeWithParents(node.parent), true);
+    }
+    else if (node instanceof Light) {
+        clone = node.clone(node.name, cloneNodeWithParents(node.parent));
+    }
+    else if (node) {
+        throw new Error(`Cloning of "${node === null || node === void 0 ? void 0 : node.constructor.name}" is not implemented (yet).`);
+    }
+    return clone;
+};
+/**
+ * @param node
+ * @param deep
+ * @param prefix
+ * @return TransformNode
+ */
+const cloneTransformNodeMaterial = function (node, prefix = '', deep = true) {
+    if (node instanceof AbstractMesh && node.material) {
+        const newMatName = DottedPath.create(prefix).addParts([node.material.name, 'clone', node.uniqueId.toString()]);
+        node.material = node.material.clone(newMatName.path);
+    }
+    if (deep) {
+        const children = node.getChildTransformNodes(true);
+        children.forEach(child => cloneTransformNodeMaterial(child, prefix, deep));
+    }
+    return node;
+};
+/**
+ * @param node
+ * @param deep
+ * @param metadata
+ */
+const injectNodeMetadata = function (node, metadata, deep = true) {
+    node.metadata = merge({}, node.metadata, metadata);
+    if (deep && node instanceof TransformNode) {
+        const children = node.getChildTransformNodes(true);
+        children.forEach(child => injectNodeMetadata(child, metadata, deep));
+    }
+};
+/**
+ * @param node
+ * @param assertCallable
+ * @param callableParameters
+ * @param deep
+ */
+const assertTransformNode = function (node, assertCallable, callableParameters = [], deep = true) {
+    assertCallable(node, ...callableParameters);
+    if (deep) {
+        const children = node.getChildTransformNodes(true);
+        children.forEach(child => assertTransformNode(child, assertCallable, callableParameters, deep));
+    }
+};
+/**
+ * @param node
+ * @param deep
+ */
+const activateTransformNode = function (node, deep = true) {
+    node.setEnabled(true);
+    /*
+      if( node instanceof AbstractMesh ) {
+          node.visibility = 1;
+          node.isPickable = true;
+      }
+      */
+    if (deep) {
+        node.getChildTransformNodes(true).forEach(child => activateTransformNode(child, deep));
+    }
+};
+/**
+ * @param node
+ * @param deep
+ */
+const deactivateTransformNode = function (node, deep = true) {
+    node.setEnabled(false);
+    /*
+      if( node instanceof AbstractMesh ) {
+          node.visibility = 0;
+          node.isPickable = false;
+      }
+      */
+    if (deep) {
+        node.getChildTransformNodes(true).forEach(child => deactivateTransformNode(child, deep));
+    }
+};
+/**
+ * @param node
+ */
+const enableNodeWithParents = function (node) {
+    node.setEnabled(true);
+    if (node.parent) {
+        enableNodeWithParents(node.parent);
+    }
+};
+/**
+ * @param node
+ */
+const disableNodeWithParents = function (node) {
+    node.setEnabled(false);
+    if (node.parent) {
+        disableNodeWithParents(node.parent);
+    }
+};
+/**
+ * Applies a {@link TransformationDefinition} consecutively to ensure dependencies in positioning etc.
+ * @param node
+ * @param transformation
+ */
+const transformTransformNode = function (node, transformation) {
+    // scaling
+    if (!has(node.metadata, 'scaling.initial')) {
+        injectNodeMetadata(node, { 'scaling.initial': node.scaling }, false);
+    }
+    const initialScaling = get(node.metadata, 'scaling.initial');
+    node.scaling = initialScaling.multiply(transformation.scaling);
+    // position
+    if (!has(node.metadata, 'position.initial')) {
+        injectNodeMetadata(node, { 'position.initial': node.absolutePosition.clone() }, false);
+    }
+    const initialPosition = get(node.metadata, 'position.initial');
+    node.setAbsolutePosition(initialPosition.add(transformation.position).multiply(transformation.scaling));
+    // rotation
+    if (!has(node.metadata, 'rotation.initial')) {
+        let rotationQuaternion = node.rotationQuaternion;
+        if (!rotationQuaternion) {
+            rotationQuaternion = Quaternion.RotationYawPitchRoll(node.rotation.x, node.rotation.y, node.rotation.z);
+        }
+        injectNodeMetadata(node, { 'rotation.initial': rotationQuaternion.asArray() }, false);
+    }
+    const initialRotationQuaternion = Quaternion.FromArray(get(node.metadata, 'rotation.initial'));
+    node.rotationQuaternion = initialRotationQuaternion;
+    node.rotateAround(Vector3.Zero(), Axis.X, transformation.rotation.x);
+    node.rotateAround(Vector3.Zero(), Axis.Y, transformation.rotation.y);
+    node.rotateAround(Vector3.Zero(), Axis.Z, transformation.rotation.z);
+    node.computeWorldMatrix(true);
+};
+/**
+ * Apply changes of environment (background texture, etc.) consecutively in order to avoid dependency related issues.
+ * @param scene
+ * @param envDef
+ */
+const changeEnvironment = function (scene, envDef) {
+    var _a, _b;
+    // issue warning if both background texture and usedefault are set
+    if (envDef.environmentUseDefault && envDef.environmentBackground) {
+        console.warn(`!!! Warning !!! Spec parameter \'environment.usedefault\' is being overruled by \'environment.background\'.`);
+    }
+    const useDefaultEnv = envDef.environmentUseDefault && !envDef.environmentBackground;
+    // 1) set ENVIRONMENT_COLOR
+    const clearColorBefore = scene.clearColor.toString();
+    scene.clearColor = envDef.environmentColor
+        ? Color4.FromColor3(envDef.environmentColor)
+        : useDefaultEnv
+            ? defaultEnvHelperColor
+            : defaultSceneClearColor;
+    const clearColorChanged = clearColorBefore !== scene.clearColor.toString();
+    // Remove all URI params from given env URL as `CubeTexture.CreateFromPrefilteredData` does not work correctly with
+    // URLs which contain URI params.
+    // E.g. `https://some.url/.../studio.env?name=defaultEnv` throws an exception whilst `https://some.url/.../studio.env`
+    // works as expected.
+    //
+    // See BJS forum for more details:
+    // https://forum.babylonjs.com/t/cubetexture-createfromprefiltereddata-does-not-work-with-url-that-contains-uri-params/34097
+    const newEnvUrl = (_a = envDef.environment) === null || _a === void 0 ? void 0 : _a.split('?')[0];
+    // 2) dispose existing & set new ENVIRONMENT (==texture)
+    const curEnvTexture = scene.environmentTexture;
+    const envTextureChanged = newEnvUrl !== (curEnvTexture === null || curEnvTexture === void 0 ? void 0 : curEnvTexture.url);
+    if (curEnvTexture && (!newEnvUrl || envTextureChanged)) {
+        curEnvTexture.dispose();
+    }
+    const rotation = envDef.environmentRotation !== undefined ? Tools.ToRadians(envDef.environmentRotation) : 0;
+    if (newEnvUrl && envTextureChanged) {
+        const envTexture = CubeTexture.CreateFromPrefilteredData(newEnvUrl, scene);
+        envTexture.rotationY = rotation;
+        scene.environmentTexture = envTexture;
+    }
+    else if (curEnvTexture && curEnvTexture.rotationY !== rotation) {
+        curEnvTexture.rotationY = rotation;
+    }
+    // 3) dispose existing & set new ENVIRONMENT_BACKGROUND
+    const curDome = scene.getNodeByName(backgroundDomeName);
+    const backgroundUrlChanged = envDef.environmentBackground !== (curDome === null || curDome === void 0 ? void 0 : curDome.texture.url);
+    if (curDome && (!envDef.environmentBackground || backgroundUrlChanged)) {
+        curDome.dispose();
+    }
+    const rotationPhotoDome = -1 * rotation;
+    if (envDef.environmentBackground && backgroundUrlChanged) {
+        const textureUrl = envDef.environmentBackground;
+        const dome = new PhotoDome(backgroundDomeName, textureUrl, { resolution: 32, size: 450 }, scene);
+        // Rotate submesh to get them in line with environment texture
+        dome.getChildMeshes(true)[0].rotation.y = Tools.ToRadians(90);
+        dome.rotation.y = rotationPhotoDome;
+    }
+    else if (curDome && curDome.rotation.y !== rotationPhotoDome) {
+        curDome.rotation.y = rotationPhotoDome;
+    }
+    // 4) dispose existing & set new ENVIRONMENT_USEDEFAULT (only if no background is set)
+    const curEnvHelper = (_b = scene.metadata) === null || _b === void 0 ? void 0 : _b[envHelperMetadataName];
+    if (curEnvHelper && !useDefaultEnv) {
+        curEnvHelper.dispose();
+        delete scene.metadata[envHelperMetadataName];
+    }
+    const envHelperMainColor = Color3.FromArray(scene.clearColor.asArray());
+    if (useDefaultEnv && !curEnvHelper) {
+        const envHelper = scene.createDefaultEnvironment({ sizeAuto: true });
+        envHelper === null || envHelper === void 0 ? void 0 : envHelper.setMainColor(envHelperMainColor);
+        if (envHelper) {
+            scene.metadata = merge({}, scene.metadata, { [envHelperMetadataName]: envHelper });
+        }
+    }
+    else if (curEnvHelper && useDefaultEnv && clearColorChanged) {
+        curEnvHelper.setMainColor(envHelperMainColor);
+    }
+    // 5) set ENVIRONMENT_INTENSITY
+    if (envDef.environmentIntensity !== undefined) {
+        scene.environmentIntensity = envDef.environmentIntensity;
+    }
+};
+/**
+ * @param node
+ * @param materialName
+ * @param deep
+ */
+const setMaterial = function (variant, node, materialName, deep = true) {
+    if (node instanceof AbstractMesh) {
+        const hasMissingMaterial = has(node.metadata, missingMaterialMetadataName);
+        if (node.isEnabled()) {
+            node.material = variant.getMaterial(materialName);
+            if (hasMissingMaterial) {
+                delete node.metadata[missingMaterialMetadataName];
+            }
+        }
+        else {
+            injectNodeMetadata(node, { [missingMaterialMetadataName]: materialName }, false);
+            // If it already had the missing material flag before, there already exists an observer...
+            if (!hasMissingMaterial) {
+                addMissingMaterialObserver(node);
+            }
+        }
+    }
+    if (deep) {
+        node.getChildTransformNodes(true).forEach(child => setMaterial(variant, child, materialName, deep));
+    }
+};
+/**
+ * !!! Warning !!!
+ * This function is not public API. Whilst it can help solving certain problems, it only works reliably in well defined
+ * situations and can cause unwanted side effects under some conditions. Use carefully at your own risk!
+ *
+ * See https://combeenation.myjetbrains.com/youtrack/issue/CB-5906 for further details regarding this warning.
+ *
+ * Set material of an instanced meshes source mesh.
+ * Changes the material of all instanced meshes which have the same source mesh.
+ *
+ * @param node
+ * @param material
+ * @param deep
+ *
+ * @ignore
+ */
+const setSourceNodeMaterial = function (node, material, deep = true) {
+    const warn = `	You're using "setSourceNodeMaterial" which is not public API.
+	Whilst it can help solving certain problems, it only works reliably in well defined situations and can cause unwanted side effects under some conditions.
+	Use carefully at your own risk!`;
+    console.warn(`!!! Warning !!!\n${warn}`);
+    if (node instanceof InstancedMesh) {
+        node.sourceMesh.material = material;
+    }
+    if (deep) {
+        node.getChildTransformNodes(true).forEach(child => setSourceNodeMaterial(child, material, deep));
+    }
+};
+/**
+ * @param node
+ * @param color
+ * @param deep
+ */
+const setMaterialColor = function (node, color, deep = true) {
+    if (node instanceof AbstractMesh && node.material) {
+        const materialCls = node.material.getClassName();
+        switch (materialCls) {
+            case 'PBRMaterial':
+                node.material.albedoColor = color.toLinearSpace();
+                break;
+            case 'StandardMaterial':
+                node.material.diffuseColor = color;
+                break;
+            default:
+                throw new Error(`Setting color for material of instance "${materialCls}" not implemented (yet).`);
+        }
+    }
+    if (deep) {
+        node.getChildTransformNodes(true).forEach(child => setMaterialColor(child, color, deep));
+    }
+};
+/**
+ * @param node
+ * @param texture
+ * @param deep
+ */
+const setMaterialTexture = function (node, texture, deep = true) {
+    if (node instanceof AbstractMesh && node.material) {
+        const materialCls = node.material.getClassName();
+        switch (materialCls) {
+            case 'PBRMaterial':
+                node.material.albedoTexture = texture;
+                break;
+            case 'StandardMaterial':
+                node.material.diffuseTexture = texture;
+                break;
+            default:
+                throw new Error(`Setting texture for material of instance "${materialCls}" not implemented (yet).`);
+        }
+    }
+    if (deep) {
+        node.getChildTransformNodes(true).forEach(child => setMaterialTexture(child, texture, deep));
+    }
+};
+/**
+ * @param node
+ * @param metallness
+ * @param deep
+ */
+const setMaterialMetallness = function (node, metallness, deep = true) {
+    if (node instanceof AbstractMesh && node.material) {
+        const materialCls = node.material.getClassName();
+        switch (materialCls) {
+            case 'PBRMaterial':
+                node.material.metallic = metallness;
+                break;
+            default:
+                throw new Error(`Setting metallness for material of instance "${materialCls}" not implemented (yet).`);
+        }
+    }
+    if (deep) {
+        node.getChildTransformNodes(true).forEach(child => setMaterialMetallness(child, metallness, deep));
+    }
+};
+/**
+ * @param node
+ * @param roughness
+ * @param deep
+ */
+const setMaterialRoughness = function (node, roughness, deep = true) {
+    if (node instanceof AbstractMesh && node.material) {
+        const materialCls = node.material.getClassName();
+        switch (materialCls) {
+            case 'PBRMaterial':
+                node.material.roughness = roughness;
+                break;
+            case 'StandardMaterial':
+                node.material.roughness = roughness;
+                break;
+            default:
+                throw new Error(`Setting roughness for material of instance "${materialCls}" not implemented (yet).`);
+        }
+    }
+    if (deep) {
+        node.getChildTransformNodes(true).forEach(child => setMaterialRoughness(child, roughness, deep));
+    }
+};
+/**
+ * @param node
+ * @param layer
+ * @param color
+ * @param deep
+ */
+const addToHighlightLayer = function (layer, color, node, deep = true) {
+    if (node instanceof AbstractMesh) {
+        layer.addMesh(node, color);
+    }
+    if (deep) {
+        node.getChildTransformNodes(true).forEach(child => addToHighlightLayer(layer, color, child, deep));
+    }
+};
+/**
+ * @param node
+ * @param layer
+ * @param deep
+ */
+const removeFromHighlightLayer = function (layer, node, deep = true) {
+    if (node instanceof AbstractMesh) {
+        layer.removeMesh(node);
+    }
+    if (deep) {
+        node.getChildTransformNodes(true).forEach(child => removeFromHighlightLayer(layer, child, deep));
+    }
+};
+/**
+ * @param node
+ * @param receiveShadows
+ * @param deep
+ */
+const setReceiveShadows = function (node, receiveShadows, deep = true) {
+    if (node instanceof AbstractMesh) {
+        node.receiveShadows = receiveShadows;
+    }
+    if (deep) {
+        node.getChildTransformNodes(true).forEach(child => setReceiveShadows(child, receiveShadows, deep));
+    }
+};
+/**
+ * @param node
+ * @param generator
+ * @param deep
+ */
+const addToShadowGenerator = function (generator, node, deep = true) {
+    if (node instanceof AbstractMesh) {
+        // We have to remove the node because there's no duplicate check in babylon
+        generator.removeShadowCaster(node, false);
+        generator.addShadowCaster(node, false);
+    }
+    if (deep) {
+        node.getChildTransformNodes(true).forEach(child => addToShadowGenerator(generator, child, deep));
+    }
+};
+/**
+ * @param node
+ * @param generator
+ * @param deep
+ */
+const removeFromShadowGenerator = function (generator, node, deep = true) {
+    if (node instanceof AbstractMesh) {
+        generator.removeShadowCaster(node, false);
+    }
+    if (deep) {
+        node.getChildTransformNodes(true).forEach(child => removeFromShadowGenerator(generator, child, deep));
+    }
+};
+/**
+ * https://forum.babylonjs.com/t/get-mesh-bounding-box-position-and-size-in-2d-screen-coordinates/1058/3
+ * @param mesh
+ * @param scene
+ * @param canvas
+ */
+const getClientRectFromMesh = function (mesh, scene, canvas) {
+    // get bounding box of the mesh
+    const meshVectors = mesh.getBoundingInfo().boundingBox.vectors;
+    // get the matrix and viewport needed to project the vectors onto the screen
+    const worldMatrix = mesh.getWorldMatrix();
+    const transformMatrix = scene.getTransformMatrix();
+    const viewport = scene.activeCamera.viewport;
+    // loop though all the vectors and project them against the current camera viewport to get a set of coordinates
+    const coordinates = meshVectors.map(vector => {
+        const projection = Vector3.Project(vector, worldMatrix, transformMatrix, viewport);
+        projection.x = projection.x * canvas.clientWidth;
+        projection.y = projection.y * canvas.clientHeight;
+        return projection;
+    });
+    // get the min and max for all the coordinates so we can calculate the largest possible screen size
+    const maxX = Math.max.apply(Math, coordinates.map(o => o.x));
+    const minX = Math.min.apply(Math, coordinates.map(o => o.x));
+    const maxY = Math.max.apply(Math, coordinates.map(o => o.y));
+    const minY = Math.min.apply(Math, coordinates.map(o => o.y));
+    // return a ClientRect from this
+    return {
+        width: maxX - minX,
+        height: maxY - minY,
+        left: minX,
+        top: minY,
+        right: maxX,
+        bottom: maxY,
+    };
+};
+export { getRootNode, mapToDottedNodes, getDottedPathForNode, cloneTransformNode, cloneNodeWithParents, cloneTransformNodeMaterial, injectNodeMetadata, assertTransformNode, activateTransformNode, deactivateTransformNode, enableNodeWithParents, disableNodeWithParents, transformTransformNode, setMaterial, setSourceNodeMaterial, setMaterialColor, setMaterialTexture, setMaterialMetallness, setMaterialRoughness, addToHighlightLayer, removeFromHighlightLayer, setReceiveShadows, addToShadowGenerator, removeFromShadowGenerator, getClientRectFromMesh, changeEnvironment, backgroundDomeName, envHelperMetadataName, };
 //# sourceMappingURL=babylonHelper.js.map