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

package/src/internal/cloning-helper.ts

@@ -1,225 +1,225 @@
-import {
-  AbstractMesh,
-  AssetContainer,
-  InstancedMesh,
-  Mesh,
-  MorphTargetManager,
-  NodeNamingStrategy,
-  Scene,
-  TagNamingStrategy,
-  TransformNode,
-} from '../index';
-import {
-  clearInternalMetadataValue,
-  cloneInternalMetadata,
-  cloneMetadata,
-  getInternalMetadataValue,
-  setInternalMetadataValue,
-} from './metadata-helper';
-import { cloneTags, getTags, setTags } from './tags-helper';
-
-const _defaultNodeNamingStrategy: NodeNamingStrategy = (node: TransformNode, newModelName: string): string => {
-  return `${node.name}.${newModelName}`;
-};
-const _defaultTagNamingStrategy: TagNamingStrategy = (tag: string, newModelName: string): string => {
-  // don't rename tags by default
-  return tag;
-};
-
-/**
- * Clones the node hierarchy of the asset container with some special treatment that differs from Babylon.js default
- * cloning behaviour, such as:
- * - create new instances of morph target manager
- * - deep cloning internal metadata
- * - deep cloning metadata and tags for instanced meshes
- * - reassigns source meshes in cloned asset container
- * Furthermore there is the possibility to adjust naming of nodes and tags in the cloned asset container
- */
-export function cloneModelAssetContainer(
-  sourceAssetContainer: AssetContainer,
-  newModelName: string,
-  renaming: {
-    nodeNamingStrategy?: NodeNamingStrategy;
-    tagNamingStrategy?: TagNamingStrategy;
-  },
-  scene: Scene
-): AssetContainer {
-  const targetAssetContainer = new AssetContainer(scene);
-
-  sourceAssetContainer.rootNodes.forEach(node => {
-    if (node instanceof TransformNode) {
-      // this is the actual node tree cloning procedure
-      _cloneNode(node, newModelName, null, targetAssetContainer, {
-        nodeNamingStrategy: renaming?.nodeNamingStrategy,
-        tagNamingStrategy: renaming?.tagNamingStrategy,
-      });
-    }
-  });
-
-  targetAssetContainer.populateRootNodes();
-  targetAssetContainer.rootNodes.forEach(node => {
-    if (node instanceof TransformNode) {
-      // reassigning instanced meshes can only be done after the model has been fully cloned, as we can't be sure if
-      // the source or instanced mesh is handled prior
-      _reAssignSourceMesh(node, sourceAssetContainer.meshes, targetAssetContainer.meshes);
-    }
-  });
-
-  // morph target manager is not cloned per default, therefore morph targets would affect original and cloned model at
-  // the same time, which we don't want
-  sourceAssetContainer.morphTargetManagers.forEach(sourceMTM => {
-    cloneMorphTargetManager(sourceMTM, targetAssetContainer);
-  });
-
-  _clearCloningMetadata(sourceAssetContainer);
-  _clearCloningMetadata(targetAssetContainer);
-
-  // hide immediately, so that show model code can do it's thing (scene preparation) before finally showing the model
-  targetAssetContainer.removeAllFromScene();
-
-  return targetAssetContainer;
-}
-
-/**
- * Helper function for cloning a morph target manager and updating all the mesh assignments.
- * Meshes need to be already available in the target asset container.
- */
-export function cloneMorphTargetManager(
-  sourceMTM: MorphTargetManager,
-  targetAssetContainer: AssetContainer
-): MorphTargetManager {
-  const clonedMTM = sourceMTM.clone();
-
-  clonedMTM._parentContainer = targetAssetContainer;
-  targetAssetContainer.morphTargetManagers.push(clonedMTM);
-
-  targetAssetContainer.meshes.forEach(mesh => {
-    if (mesh.morphTargetManager === sourceMTM) {
-      mesh.morphTargetManager = clonedMTM;
-    }
-  });
-
-  return clonedMTM;
-}
-
-/**
- * The actual geometry cloning function.
- * Calls "clone" function of dedicated Node type and recourses into children to clone the whole node tree.
- * Adds temporary metadata for special treatment of certain node types (e.g. InstancedMesh).
- */
-function _cloneNode(
-  node: TransformNode,
-  newModelName: string,
-  newParent: TransformNode | null,
-  assetContainer: AssetContainer,
-  renaming: {
-    nodeNamingStrategy?: NodeNamingStrategy;
-    tagNamingStrategy?: TagNamingStrategy;
-  }
-): void {
-  const nodeNamingStrategy = renaming.nodeNamingStrategy ?? _defaultNodeNamingStrategy;
-  const tagNamingStrategy = renaming.tagNamingStrategy ?? _defaultTagNamingStrategy;
-
-  const cloneName = nodeNamingStrategy(node, newModelName);
-  const clone = node.clone(cloneName, newParent, true);
-  if (!clone) {
-    throw new Error(`Cloning node "${node.name}" failed`);
-  }
-
-  clone.id = cloneName;
-  // create a deep clone for internal metadata, as the default clone function uses the same assignment of the sources
-  // internal metadata
-  cloneInternalMetadata(node, clone);
-  // ATM the assignment from clone to source is needed for reassigning instanced meshes after cloning
-  // may be usefull for other node types in the future as well
-  setInternalMetadataValue(clone, 'cloneSource', node.uniqueId);
-  setInternalMetadataValue(node, 'cloneTarget', clone.uniqueId);
-
-  if (node instanceof InstancedMesh) {
-    _cloneInstancedMeshData(node, clone as InstancedMesh);
-  }
-
-  const sourceTags = getTags(node);
-  const mappedTags = sourceTags.map(tag => tagNamingStrategy(tag, newModelName));
-  setTags(clone, mappedTags);
-
-  clone._parentContainer = assetContainer;
-  // TODO WTT: create global helper function for distinguishing between transform nodes and meshes
-  if (clone instanceof AbstractMesh) {
-    assetContainer.meshes.push(clone);
-  } else {
-    assetContainer.transformNodes.push(clone);
-  }
-
-  const children = node.getChildTransformNodes(true);
-  children.forEach(child => _cloneNode(child, newModelName, clone, assetContainer, renaming));
-}
-
-/**
- * Cloned instanced meshes are having the same source mesh as their cloning source.
- * However we want the cloned source mesh to be the actual source.
- * Exchanging and reassigning is done within this function.
- * Operates on the given `node` and all its children recursively.
- */
-function _reAssignSourceMesh(node: TransformNode, sourceMeshes: AbstractMesh[], clonedMeshes: AbstractMesh[]): void {
-  if (node instanceof InstancedMesh) {
-    // find the cloned instance and source mesh
-    const clonedInstance = node;
-    const originalInstance = _findByUniqueId(
-      sourceMeshes,
-      getInternalMetadataValue(clonedInstance, 'cloneSource') as number
-    );
-    if (originalInstance instanceof InstancedMesh) {
-      const originalSource = originalInstance.sourceMesh;
-      const clonedSource = _findByUniqueId(
-        clonedMeshes,
-        getInternalMetadataValue(originalSource, 'cloneTarget') as number
-      );
-      if (clonedSource instanceof Mesh) {
-        // it's not possible to just exchange the source mesh => readonly property
-        // we have to create a new clone with the correct source mesh
-        const exchangedInstance = clonedInstance.clone(clonedInstance.name, clonedInstance.parent, true, clonedSource);
-        clonedInstance._parentContainer!.meshes.push(exchangedInstance);
-
-        _cloneInstancedMeshData(clonedInstance, exchangedInstance);
-
-        // re-reference the childs of the cloned instance as well
-        const childs = clonedInstance.getChildTransformNodes(true);
-        childs.forEach(child => (child.parent = exchangedInstance));
-      }
-    }
-
-    // old instance mesh is not needed anymore and can be disposed
-    clonedInstance.dispose();
-  }
-
-  // recurse into childs
-  const children = node.getChildTransformNodes(true);
-  children.forEach(child => _reAssignSourceMesh(child, sourceMeshes, clonedMeshes));
-}
-
-/**
- * Removes metadata entries "cloneSource" and "cloneTarget" from all meshes and transform nodes inside the asset
- * container
- */
-function _clearCloningMetadata(assetContainer: AssetContainer): void {
-  [...assetContainer.meshes, ...assetContainer.transformNodes].forEach(node => {
-    clearInternalMetadataValue(node, 'cloneSource');
-    clearInternalMetadataValue(node, 'cloneTarget');
-  });
-}
-
-/**
- * "InstancedMesh.clone" function doesn't clone tags and metadata, also the enabled state doesn't seem to be cloned
- * correctly.
- * This function adjusts the behaviour to fulfill our expectations.
- */
-function _cloneInstancedMeshData(sourceInstancedMesh: InstancedMesh, targetInstancedMesh: InstancedMesh): void {
-  targetInstancedMesh.setEnabled(sourceInstancedMesh.isEnabled(false));
-  cloneMetadata(sourceInstancedMesh, targetInstancedMesh);
-  cloneTags(sourceInstancedMesh, targetInstancedMesh);
-}
-
-function _findByUniqueId(nodes: TransformNode[], uniqueId: number): TransformNode | undefined {
-  return nodes.find(node => node.uniqueId === uniqueId);
-}
+import {
+  AbstractMesh,
+  AssetContainer,
+  InstancedMesh,
+  Mesh,
+  MorphTargetManager,
+  NodeNamingStrategy,
+  Scene,
+  TagNamingStrategy,
+  TransformNode,
+} from '../index';
+import {
+  clearInternalMetadataValue,
+  cloneInternalMetadata,
+  cloneMetadata,
+  getInternalMetadataValue,
+  setInternalMetadataValue,
+} from './metadata-helper';
+import { cloneTags, getTags, setTags } from './tags-helper';
+
+const _defaultNodeNamingStrategy: NodeNamingStrategy = (node: TransformNode, newModelName: string): string => {
+  return `${node.name}.${newModelName}`;
+};
+const _defaultTagNamingStrategy: TagNamingStrategy = (tag: string, newModelName: string): string => {
+  // don't rename tags by default
+  return tag;
+};
+
+/**
+ * Clones the node hierarchy of the asset container with some special treatment that differs from Babylon.js default
+ * cloning behaviour, such as:
+ * - create new instances of morph target manager
+ * - deep cloning internal metadata
+ * - deep cloning metadata and tags for instanced meshes
+ * - reassigns source meshes in cloned asset container
+ * Furthermore there is the possibility to adjust naming of nodes and tags in the cloned asset container
+ */
+export function cloneModelAssetContainer(
+  sourceAssetContainer: AssetContainer,
+  newModelName: string,
+  renaming: {
+    nodeNamingStrategy?: NodeNamingStrategy;
+    tagNamingStrategy?: TagNamingStrategy;
+  },
+  scene: Scene
+): AssetContainer {
+  const targetAssetContainer = new AssetContainer(scene);
+
+  sourceAssetContainer.rootNodes.forEach(node => {
+    if (node instanceof TransformNode) {
+      // this is the actual node tree cloning procedure
+      _cloneNode(node, newModelName, null, targetAssetContainer, {
+        nodeNamingStrategy: renaming?.nodeNamingStrategy,
+        tagNamingStrategy: renaming?.tagNamingStrategy,
+      });
+    }
+  });
+
+  targetAssetContainer.populateRootNodes();
+  targetAssetContainer.rootNodes.forEach(node => {
+    if (node instanceof TransformNode) {
+      // reassigning instanced meshes can only be done after the model has been fully cloned, as we can't be sure if
+      // the source or instanced mesh is handled prior
+      _reAssignSourceMesh(node, sourceAssetContainer.meshes, targetAssetContainer.meshes);
+    }
+  });
+
+  // morph target manager is not cloned per default, therefore morph targets would affect original and cloned model at
+  // the same time, which we don't want
+  sourceAssetContainer.morphTargetManagers.forEach(sourceMTM => {
+    cloneMorphTargetManager(sourceMTM, targetAssetContainer);
+  });
+
+  _clearCloningMetadata(sourceAssetContainer);
+  _clearCloningMetadata(targetAssetContainer);
+
+  // hide immediately, so that show model code can do it's thing (scene preparation) before finally showing the model
+  targetAssetContainer.removeAllFromScene();
+
+  return targetAssetContainer;
+}
+
+/**
+ * Helper function for cloning a morph target manager and updating all the mesh assignments.
+ * Meshes need to be already available in the target asset container.
+ */
+export function cloneMorphTargetManager(
+  sourceMTM: MorphTargetManager,
+  targetAssetContainer: AssetContainer
+): MorphTargetManager {
+  const clonedMTM = sourceMTM.clone();
+
+  clonedMTM._parentContainer = targetAssetContainer;
+  targetAssetContainer.morphTargetManagers.push(clonedMTM);
+
+  targetAssetContainer.meshes.forEach(mesh => {
+    if (mesh.morphTargetManager === sourceMTM) {
+      mesh.morphTargetManager = clonedMTM;
+    }
+  });
+
+  return clonedMTM;
+}
+
+/**
+ * The actual geometry cloning function.
+ * Calls "clone" function of dedicated Node type and recourses into children to clone the whole node tree.
+ * Adds temporary metadata for special treatment of certain node types (e.g. InstancedMesh).
+ */
+function _cloneNode(
+  node: TransformNode,
+  newModelName: string,
+  newParent: TransformNode | null,
+  assetContainer: AssetContainer,
+  renaming: {
+    nodeNamingStrategy?: NodeNamingStrategy;
+    tagNamingStrategy?: TagNamingStrategy;
+  }
+): void {
+  const nodeNamingStrategy = renaming.nodeNamingStrategy ?? _defaultNodeNamingStrategy;
+  const tagNamingStrategy = renaming.tagNamingStrategy ?? _defaultTagNamingStrategy;
+
+  const cloneName = nodeNamingStrategy(node, newModelName);
+  const clone = node.clone(cloneName, newParent, true);
+  if (!clone) {
+    throw new Error(`Cloning node "${node.name}" failed`);
+  }
+
+  clone.id = cloneName;
+  // create a deep clone for internal metadata, as the default clone function uses the same assignment of the sources
+  // internal metadata
+  cloneInternalMetadata(node, clone);
+  // ATM the assignment from clone to source is needed for reassigning instanced meshes after cloning
+  // may be usefull for other node types in the future as well
+  setInternalMetadataValue(clone, 'cloneSource', node.uniqueId);
+  setInternalMetadataValue(node, 'cloneTarget', clone.uniqueId);
+
+  if (node instanceof InstancedMesh) {
+    _cloneInstancedMeshData(node, clone as InstancedMesh);
+  }
+
+  const sourceTags = getTags(node);
+  const mappedTags = sourceTags.map(tag => tagNamingStrategy(tag, newModelName));
+  setTags(clone, mappedTags);
+
+  clone._parentContainer = assetContainer;
+  // TODO WTT: create global helper function for distinguishing between transform nodes and meshes
+  if (clone instanceof AbstractMesh) {
+    assetContainer.meshes.push(clone);
+  } else {
+    assetContainer.transformNodes.push(clone);
+  }
+
+  const children = node.getChildTransformNodes(true);
+  children.forEach(child => _cloneNode(child, newModelName, clone, assetContainer, renaming));
+}
+
+/**
+ * Cloned instanced meshes are having the same source mesh as their cloning source.
+ * However we want the cloned source mesh to be the actual source.
+ * Exchanging and reassigning is done within this function.
+ * Operates on the given `node` and all its children recursively.
+ */
+function _reAssignSourceMesh(node: TransformNode, sourceMeshes: AbstractMesh[], clonedMeshes: AbstractMesh[]): void {
+  if (node instanceof InstancedMesh) {
+    // find the cloned instance and source mesh
+    const clonedInstance = node;
+    const originalInstance = _findByUniqueId(
+      sourceMeshes,
+      getInternalMetadataValue(clonedInstance, 'cloneSource') as number
+    );
+    if (originalInstance instanceof InstancedMesh) {
+      const originalSource = originalInstance.sourceMesh;
+      const clonedSource = _findByUniqueId(
+        clonedMeshes,
+        getInternalMetadataValue(originalSource, 'cloneTarget') as number
+      );
+      if (clonedSource instanceof Mesh) {
+        // it's not possible to just exchange the source mesh => readonly property
+        // we have to create a new clone with the correct source mesh
+        const exchangedInstance = clonedInstance.clone(clonedInstance.name, clonedInstance.parent, true, clonedSource);
+        clonedInstance._parentContainer!.meshes.push(exchangedInstance);
+
+        _cloneInstancedMeshData(clonedInstance, exchangedInstance);
+
+        // re-reference the childs of the cloned instance as well
+        const childs = clonedInstance.getChildTransformNodes(true);
+        childs.forEach(child => (child.parent = exchangedInstance));
+      }
+    }
+
+    // old instance mesh is not needed anymore and can be disposed
+    clonedInstance.dispose();
+  }
+
+  // recurse into childs
+  const children = node.getChildTransformNodes(true);
+  children.forEach(child => _reAssignSourceMesh(child, sourceMeshes, clonedMeshes));
+}
+
+/**
+ * Removes metadata entries "cloneSource" and "cloneTarget" from all meshes and transform nodes inside the asset
+ * container
+ */
+function _clearCloningMetadata(assetContainer: AssetContainer): void {
+  [...assetContainer.meshes, ...assetContainer.transformNodes].forEach(node => {
+    clearInternalMetadataValue(node, 'cloneSource');
+    clearInternalMetadataValue(node, 'cloneTarget');
+  });
+}
+
+/**
+ * "InstancedMesh.clone" function doesn't clone tags and metadata, also the enabled state doesn't seem to be cloned
+ * correctly.
+ * This function adjusts the behaviour to fulfill our expectations.
+ */
+function _cloneInstancedMeshData(sourceInstancedMesh: InstancedMesh, targetInstancedMesh: InstancedMesh): void {
+  targetInstancedMesh.setEnabled(sourceInstancedMesh.isEnabled(false));
+  cloneMetadata(sourceInstancedMesh, targetInstancedMesh);
+  cloneTags(sourceInstancedMesh, targetInstancedMesh);
+}
+
+function _findByUniqueId(nodes: TransformNode[], uniqueId: number): TransformNode | undefined {
+  return nodes.find(node => node.uniqueId === uniqueId);
+}

package/src/internal/device-helper.ts

@@ -1,25 +1,25 @@
-import { LimitTextureSizeConfig } from '../index';
-
-/**
- * Checks if the current device is an iPhone
- */
-export function getIsIPhone(): boolean {
-  const isIPhone = /iPhone/.test(navigator.userAgent);
-
-  return isIPhone;
-}
-
-/**
- * Checks if the current device is "scaled down", as defined in the Spec
- */
-export function getIsScaledDownDevice(limitTextureSize: LimitTextureSizeConfig | false): boolean {
-  if (!limitTextureSize) {
-    // no down scaling defined
-    return false;
-  }
-
-  // check device
-  const deviceFits = limitTextureSize.devices === 'all' || (limitTextureSize.devices === 'iPhone' && getIsIPhone());
-
-  return deviceFits;
-}
+import { LimitTextureSizeConfig } from '../index';
+
+/**
+ * Checks if the current device is an iPhone
+ */
+export function getIsIPhone(): boolean {
+  const isIPhone = /iPhone/.test(navigator.userAgent);
+
+  return isIPhone;
+}
+
+/**
+ * Checks if the current device is "scaled down", as defined in the Spec
+ */
+export function getIsScaledDownDevice(limitTextureSize: LimitTextureSizeConfig | false): boolean {
+  if (!limitTextureSize) {
+    // no down scaling defined
+    return false;
+  }
+
+  // check device
+  const deviceFits = limitTextureSize.devices === 'all' || (limitTextureSize.devices === 'iPhone' && getIsIPhone());
+
+  return deviceFits;
+}