@archvisioninc/canvas 3.3.6 → 3.3.8

package/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(wc -l /c/Users/ArchVision/Documents/git/archvision-canvas/src/package/helpers/*.js)",
+      "Bash(npx eslint:*)"
+    ]
+  }
+}

package/README_DEV.md

@@ -30,7 +30,10 @@ You will need to be invited to the Archvision, Inc. team on [NPM](https://npmjs.
 
 Since the canvas package is under Archvision, Inc.  It will be identified as [@archvisioninc/canvas](https://npmjs.com/package/@archvisioninc/canvas).
 
-
+> npm has updated their packaging publishing process that may require the developer to add 2FA to their account.  Once this is added to the developer's account, they will need to run
+>> npm login
+>
+> to reauthenticate with the 2FA enabled.  This 2FA process will also be required when publishing a new version of canvas to npm. 
 
 ## Project structure and organization
 This project's main development environment is found in `/src`.  Each file and folder, except the `/src/package` folder,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archvisioninc/canvas",
-  "version": "3.3.6",
+  "version": "3.3.8",
   "private": false,
   "main": "dist/Canvas.js",
   "module": "dist/Canvas.js",

package/src/package/helpers/canvasUpdateHelpers.js

@@ -317,6 +317,85 @@ const dataUrlToBlob = dataURI => {
   return blob;
 };
 
+const getActiveAnimationGroup = animationGroups => {
+  const selectedAnimationIndex = scene.metadata?.selectedAnimation;
+
+  if (selectedAnimationIndex === null || selectedAnimationIndex === undefined) {
+    return null;
+  }
+
+  return animationGroups.find((_group, index) => {
+    return `${index}` === `${selectedAnimationIndex}`;
+  }) || null;
+};
+
+let animationSyncObserver = null;
+let lastAnimationSerializeAt = 0;
+const ANIMATION_SYNC_MS = 50;
+
+const pushAnimationStateToReact = () => {
+  const activeAnimationGroup = getActiveAnimationGroup(scene.animationGroups || []);
+
+  syncSelectedAnimationMeta(activeAnimationGroup);
+
+  const now = performance.now();
+  if (
+    props.setSerializedData
+    && now - lastAnimationSerializeAt >= ANIMATION_SYNC_MS
+  ) {
+    lastAnimationSerializeAt = now;
+    props.setSerializedData(serializeScene());
+  }
+};
+
+const ensureAnimationStateSync = () => {
+  if (animationSyncObserver || !scene?.onBeforeRenderObservable) {
+    return;
+  }
+
+  animationSyncObserver = scene.onBeforeRenderObservable.add(() => {
+    const activeAnimationGroup = getActiveAnimationGroup(scene.animationGroups || []);
+
+    if (!activeAnimationGroup) {
+      return;
+    }
+
+    pushAnimationStateToReact();
+  });
+};
+
+const syncSelectedAnimationMeta = animationGroup => {
+  if (!scene.metadata) return;
+
+  if (!animationGroup) {
+    scene.metadata.selectedAnimationTime = 0;
+    scene.metadata.selectedAnimationProgress = 0;
+    scene.metadata.selectedAnimationDuration = 0;
+    scene.metadata.selectedAnimationIsPlaying = false;
+    return;
+  }
+
+  const runtimeAnimation = animationGroup.animatables?.[0]?.getAnimations?.()?.[0];
+  const currentFrame = runtimeAnimation?.currentFrame ?? animationGroup.from ?? 0;
+  const from = animationGroup.from ?? 0;
+  const to = animationGroup.to ?? 0;
+  const totalFrames = Math.max(to - from, 1);
+
+  const progress = BABYLON.Scalar.Clamp(
+    (currentFrame - from) / totalFrames,
+    0,
+    1
+  );
+
+  const duration = animationGroup.getLength?.() ?? 0;
+
+  scene.metadata.selectedAnimationProgress = progress;
+  scene.metadata.selectedAnimationTime = progress * duration;
+  scene.metadata.selectedAnimationDuration = duration;
+  scene.metadata.selectedAnimationIsPlaying = Boolean(animationGroup.isPlaying);
+};
+
+
 export const updateMaterial = inboundData => {
   const { payload } = inboundData;
   const {
@@ -666,6 +745,13 @@ export const updateMesh = inboundData => {
     globalTransform,
     variantName,
     resetVariant,
+    animationId,
+    resetAnimation,
+    loopAnimation = true,
+    playAnimation,
+    pauseAnimation,
+    seekAnimation,
+    animationProgress,
     sourceUnit,
     displayUnit,
   } = payload;
@@ -773,6 +859,65 @@ export const updateMesh = inboundData => {
     newMetaDataEntry('selectedMaterialVariant', null);
   }
 
+  const animationGroups = scene.animationGroups || [];
+  const hasAnimationId = animationId !== undefined && animationId !== null && `${animationId}` !== '';
+
+  const stopAllAnimationGroups = () => {
+    animationGroups.forEach(group => {
+      group.stop();
+      group.reset();
+    });
+  };
+
+  // Reset current animation
+  if (resetAnimation) {
+    stopAllAnimationGroups();
+    newMetaDataEntry('selectedAnimation', null);
+    syncSelectedAnimationMeta(null);
+    props.setSerializedData?.(serializeScene());
+  }
+
+  // Change active animation
+  if (hasAnimationId) {
+    const animationGroup = animationGroups.find((group, index) => `${index}` === `${animationId}`);
+
+    stopAllAnimationGroups();
+
+    if (animationGroup) {
+      animationGroup.start(Boolean(loopAnimation));
+      newMetaDataEntry('selectedAnimation', `${animationId}`);
+      syncSelectedAnimationMeta(animationGroup);
+      ensureAnimationStateSync();
+      props.setSerializedData?.(serializeScene());
+    }
+  }
+
+  const activeAnimationGroup = getActiveAnimationGroup(animationGroups);
+
+  // Play current animation
+  if (playAnimation && activeAnimationGroup) {
+    activeAnimationGroup.play(Boolean(loopAnimation));
+    syncSelectedAnimationMeta(activeAnimationGroup);
+    ensureAnimationStateSync();
+    props.setSerializedData?.(serializeScene());
+  }
+
+  // Pause current animation
+  if (pauseAnimation && activeAnimationGroup) {
+    activeAnimationGroup.pause();
+    syncSelectedAnimationMeta(activeAnimationGroup);
+    props.setSerializedData?.(serializeScene());
+  }
+
+  // Seek current animation to a progress position (0–1)
+  if (seekAnimation && activeAnimationGroup && animationProgress !== undefined) {
+    const { from, to } = activeAnimationGroup;
+    const frame = from + animationProgress * (to - from);
+    activeAnimationGroup.goToFrame(frame);
+    syncSelectedAnimationMeta(activeAnimationGroup);
+    props.setSerializedData?.(serializeScene());
+  }
+
   // Bounding Box Toggle
   if (boundingBoxEnabled !== undefined) {
     toggleBoundingBoxWidget();

package/src/package/helpers/initHelpers.js

@@ -39,6 +39,7 @@ import {
   serializeScene,
   buildMeshPositionsArray,
   buildMaterialsArray,
+  buildAnimationsArray,
   updatePublish,
   buildSelectedMaterialArray,
   buildMaterialVariantsArray,
@@ -388,6 +389,8 @@ const initMetadataKeyDefaults = () => {
   newMetaDataEntry('fileName', null);
   newMetaDataEntry('uvScaleLock', false);
   newMetaDataEntry('lights', []);
+  newMetaDataEntry('animations', []);
+  newMetaDataEntry('selectedAnimation', null);
 };
 
 const checkForRootNode = () => {
@@ -506,6 +509,13 @@ export const initSceneFromFile = (sceneFromFile, fileName) => {
     newMetaDataEntry('selectedMaterials', buildSelectedMaterialArray());
     newMetaDataEntry('fileName', fileName);
     newMetaDataEntry('materialVariants', buildMaterialVariantsArray());
+    const animations = buildAnimationsArray();
+    const activeAnimationIndex = scene.animationGroups?.findIndex(group => group.isPlaying) ?? -1;
+    newMetaDataEntry('animations', animations);
+    newMetaDataEntry(
+      'selectedAnimation',
+      activeAnimationIndex >= 0 ? `${activeAnimationIndex}` : null,
+    );
     newMetaDataEntry('uvScaleLock', scene.metadata.uvScaleLock || false);
     newMetaDataEntry('lights', buildLightsArray());
 

package/src/package/helpers/utilityHelpers.js

@@ -336,6 +336,23 @@ export const buildMaterialVariantsArray = () => {
   return variants;
 };
 
+
+export const buildAnimationsArray = () => {
+  const animationGroups = scene?.animationGroups || [];
+
+  return animationGroups.map((group, index) => {
+    const fallbackLabel = `Animation ${index + 1}`;
+    const label = group.name || group.id || fallbackLabel;
+
+    return {
+      id: `${index}`,
+      index,
+      label,
+      name: group.name || '',
+    };
+  });
+};
+
 export const buildSelectedMaterialArray = () => {
   if (props.materialMode) {
     const mainMaterial = scene.metadata?.materials?.find?.(item => item.materialId === 'material');

package/dist/Canvas.js

@@ -1,67 +0,0 @@
-import _ from 'lodash';
-import React, { useRef, useEffect, useCallback } from 'react';
-import { initScene, cleanup, createScene, engine, scene, warningChecks, updateItem, getGLTFData, takePreviewScreenshots } from './helpers';
-import { CanvasContainer, RenderCanvas } from './styles';
-export let reactProps;
-const Canvas = props => {
-  const {
-    file,
-    guidURL,
-    reinitialize,
-    updateData,
-    exportModel,
-    toDownload,
-    exportType
-  } = props;
-  const canvasRef = useRef();
-  const checkForWarnings = useCallback(() => {
-    if (scene) {
-      const hasPlugin = scene?.loadingPluginName;
-      if (hasPlugin) warningChecks();
-    }
-  }, []);
-  useEffect(() => {
-    return () => {
-      cleanup();
-    };
-  }, []);
-  useEffect(() => {
-    initScene({
-      canvasRef
-    });
-  }, [canvasRef, guidURL]);
-  useEffect(() => {
-    reactProps = props;
-  }, [props]);
-  useEffect(() => {
-    const createNewScene = true;
-    if (file || guidURL && engine) createScene();
-    if (!file && !guidURL && scene) createScene(createNewScene);
-  }, [file, guidURL]);
-  useEffect(() => {
-    checkForWarnings();
-  }, [checkForWarnings]);
-  useEffect(() => {
-    if (scene && !_.isEmpty(updateData)) {
-      updateItem(updateData);
-    }
-  }, [updateData]);
-  useEffect(() => {
-    if (canvasRef && reinitialize) {
-      cleanup();
-      initScene({
-        canvasRef
-      });
-    }
-  }, [canvasRef, reinitialize]);
-  useEffect(() => {
-    if (exportModel && exportType) {
-      getGLTFData(exportType, toDownload);
-      takePreviewScreenshots();
-    }
-  }, [exportModel, exportType, toDownload]);
-  return /*#__PURE__*/React.createElement(CanvasContainer, props, /*#__PURE__*/React.createElement(RenderCanvas, {
-    ref: canvasRef
-  }));
-};
-export default Canvas;

package/dist/actions/index.js

@@ -1 +0,0 @@
-export * from './shortcutActions';

package/dist/actions/shortcutActions.js

@@ -1,313 +0,0 @@
-import * as BABYLON from 'babylonjs';
-import * as BABYLONGUI from 'babylonjs-gui';
-import { getUserMeshes, gizmoManager, newFraming, scene, selectedMeshes, theme, $selectedTheme, newColor, toggleCameraMode, getParamOfSelectedMeshes, getUserMaterials, guiTexture, getBoundingMeshData, singleMeshTNode, multiMeshTNode, createBoundingMesh, restoreParents, createSafeFrame, newMetaDataEntry, resetSelectedMeshes, buildMaterialsArray, buildSelectedMaterialArray, addAutoRotation, removeAutoRotation, autoRotation, buildMeshPositionsArray } from '../helpers';
-import { GIZMOS, GUI, MESH_PARAMS } from '../constants';
-import { exclusionMaterials, orthoOptions, dimensions, scaleUnits } from '../enums';
-import _ from 'lodash';
-export let cameraView;
-export const resetManagerGizmos = type => {
-  Object.values(GIZMOS).forEach(value => {
-    if (value !== type) {
-      const propertyName = _.camelCase(`${value}Enabled`);
-      gizmoManager[propertyName] = false;
-    }
-  });
-  dimensions.forEach(dimension => {
-    guiTexture.getControlByName(dimension.rectangle)?.dispose?.();
-    guiTexture.getControlByName(dimension.label)?.dispose?.();
-    guiTexture.getControlByName(dimension.container)?.dispose?.();
-  });
-  switch (selectedMeshes.length) {
-    case 1:
-      gizmoManager.attachToNode(singleMeshTNode);
-      break;
-    default:
-      gizmoManager.attachToNode(multiMeshTNode);
-      break;
-  }
-};
-export const toggleTurntable = override => {
-  const camera = scene.activeCamera;
-  const rotationEnabled = camera.useAutoRotationBehavior;
-  if (!autoRotation) addAutoRotation();
-  if (override !== undefined) {
-    camera.useAutoRotationBehavior = override;
-    if (override) {
-      autoRotation.attach(camera);
-      autoRotation.idleRotationSpeed = -0.1;
-      return;
-    }
-    autoRotation.detach(camera);
-    removeAutoRotation();
-    return;
-  }
-  if (rotationEnabled) {
-    autoRotation.detach(camera);
-    camera.useAutoRotationBehavior = false;
-    removeAutoRotation();
-    return;
-  }
-  autoRotation.attach(camera);
-  camera.useAutoRotationBehavior = true;
-  autoRotation.idleRotationSpeed = -0.1;
-};
-export const focusCamera = () => {
-  const camera = scene.activeCamera;
-  const userMeshes = getUserMeshes();
-  const framingBehavior = newFraming();
-  const babylonOrthographic = BABYLON.Camera.ORTHOGRAPHIC_CAMERA;
-  const isOrtho = camera.mode === babylonOrthographic;
-  const boundingMesh = scene.getMeshById('boundingMesh');
-  const meshCenter = getParamOfSelectedMeshes(MESH_PARAMS.center);
-  const framingMeshes = boundingMesh ? [boundingMesh] : userMeshes;
-  framingBehavior.framingTime = 0;
-  framingBehavior.defaultElevation = 0;
-  framingBehavior.attach?.(camera);
-  !_.isEmpty(userMeshes) ? framingBehavior.zoomOnMeshesHierarchy(framingMeshes) : camera.setTarget(BABYLON.Vector3.Zero());
-  camera.beta = Math.PI / 2;
-  if (isOrtho) {
-    camera.target = meshCenter;
-    camera.alpha = orthoOptions[cameraView].alpha;
-    camera.beta = orthoOptions[cameraView].beta;
-  }
-  framingBehavior.detach?.(camera);
-};
-export const toggleSafeFrame = (e, aspectRatio, override) => {
-  let outerFrame = guiTexture.getControlByName(GUI.outerSafeFrame);
-  if (aspectRatio) {
-    outerFrame?.dispose();
-    createSafeFrame(aspectRatio);
-    outerFrame = guiTexture.getControlByName(GUI.outerSafeFrame);
-    outerFrame.isVisible = override;
-    newMetaDataEntry('safeFrameEnabled', outerFrame.isVisible);
-    return;
-  }
-  if (override === undefined && outerFrame) {
-    outerFrame.isVisible = !outerFrame.isVisible;
-    newMetaDataEntry('safeFrameEnabled', outerFrame.isVisible);
-    return;
-  }
-};
-export const toggleInspector = () => {
-  const inspector = scene.debugLayer;
-  inspector.isVisible() ? inspector.hide() : inspector.show();
-};
-export const toggleMoveWidget = () => {
-  if (!_.isEmpty(selectedMeshes)) {
-    resetManagerGizmos(GIZMOS.PositionGizmo);
-    gizmoManager.positionGizmoEnabled = !gizmoManager.positionGizmoEnabled;
-  }
-};
-export const toggleRotateWidget = () => {
-  if (!_.isEmpty(selectedMeshes)) {
-    resetManagerGizmos(GIZMOS.RotationGizmo);
-    gizmoManager.rotationGizmoEnabled = !gizmoManager.rotationGizmoEnabled;
-  }
-};
-export const toggleScaleWidget = () => {
-  if (!_.isEmpty(selectedMeshes)) {
-    resetManagerGizmos(GIZMOS.ScaleGizmo);
-    gizmoManager.scaleGizmoEnabled = !gizmoManager.scaleGizmoEnabled;
-  }
-};
-export const toggleBoundingBoxWidget = () => {
-  const boundingMesh = scene.getMeshById('boundingMesh');
-  const boxColor = newColor(theme.colors[$selectedTheme].accent);
-  const isEnabled = gizmoManager.boundingBoxGizmoEnabled;
-  const boundingInfo = getBoundingMeshData([boundingMesh]);
-  dimensions.forEach(dimension => {
-    guiTexture.getControlByName(dimension.rectangle)?.dispose?.();
-    guiTexture.getControlByName(dimension.label)?.dispose?.();
-    guiTexture.getControlByName(dimension.container)?.dispose?.();
-  });
-  if (!gizmoManager.boundingBoxGizmoEnabled) {
-    resetManagerGizmos(GIZMOS.BoundingBoxGizmo);
-    gizmoManager.attachToMesh(boundingMesh);
-  }
-  gizmoManager.boundingBoxGizmoEnabled = !isEnabled;
-  gizmoManager.boundingBoxDragBehavior.rotateDraggedObject = false;
-  gizmoManager.boundingBoxDragBehavior.disableMovement = true;
-  gizmoManager.gizmos.boundingBoxGizmo.setEnabledScaling(false);
-  gizmoManager.gizmos.boundingBoxGizmo.setEnabledRotationAxis('');
-  gizmoManager.gizmos.boundingBoxGizmo.setColor(boxColor);
-  newMetaDataEntry('boundingBoxEnabled', !isEnabled);
-
-  // ================ Bounding Box Labels ================
-  const buildUnitLabel = dimension => {
-    const {
-      name,
-      color,
-      label,
-      rectangle,
-      container
-    } = dimension;
-    const {
-      center,
-      minimum,
-      maximumWorld,
-      minimumWorld
-    } = boundingInfo;
-    const displayUnit = scene.metadata?.selectedDisplayUnit || scene.metadata?.selectedSourceUnit;
-    const labelHeight = 36;
-    let x, y, z, value;
-    const buildValue = axis => {
-      const workingValue = Math.abs(minimumWorld[axis] - maximumWorld[axis]);
-      const meterScaleFactor = scaleUnits.find(unit => unit.abbreviation === 'm').scaleFactor;
-      const displayScaleFactor = scaleUnits.find(unit => unit.abbreviation === displayUnit || unit.name === displayUnit)?.scaleFactor || meterScaleFactor;
-      return (workingValue / displayScaleFactor).toFixed(6);
-    };
-    switch (name) {
-      case 'length':
-        x = center.x + (maximumWorld.x - minimumWorld.x) / 2;
-        y = center.y - Math.abs(minimum.y);
-        z = center.z;
-        value = buildValue('z');
-        break;
-      case 'width':
-        x = center.x;
-        y = center.y - Math.abs(minimum.y);
-        z = center.z + (maximumWorld.z - minimumWorld.z) / 2;
-        value = buildValue('x');
-        break;
-      default:
-        x = center.x + (maximumWorld.x - minimumWorld.x) / 2;
-        y = center.y;
-        z = center.z + (maximumWorld.z - minimumWorld.z) / 2;
-        value = buildValue('y');
-    }
-    const lengthPosition = new BABYLON.Vector3(x, y, z);
-    const labelRectangle = new BABYLONGUI.Rectangle(rectangle);
-    labelRectangle.width = displayUnit ? 0.14 : 0.12;
-    labelRectangle.heightInPixels = labelHeight;
-    labelRectangle.cornerRadius = 3;
-    labelRectangle.color = color;
-    labelRectangle.thickness = 1;
-    labelRectangle.background = color + 20;
-    guiTexture.addControl(labelRectangle);
-    const lengthLabel = new BABYLONGUI.TextBlock(label);
-    lengthLabel.text = `${_.startCase(name)}: ${value}${displayUnit || ''}`;
-    labelRectangle.addControl(lengthLabel);
-    const labelLinkBox = BABYLON.MeshBuilder.CreateBox(container, scene);
-    labelLinkBox.position = lengthPosition;
-    labelLinkBox.isPickable = false;
-    labelLinkBox.visibility = 0;
-    labelLinkBox.setParent(boundingMesh);
-    labelRectangle.linkWithMesh(labelLinkBox);
-    labelRectangle.linkOffsetX = 30;
-    labelRectangle.linkOffsetY = 30;
-  };
-  if (gizmoManager.boundingBoxGizmoEnabled) {
-    dimensions.forEach(dimension => buildUnitLabel(dimension));
-  }
-};
-export const hideSelected = () => {
-  selectedMeshes.forEach(mesh => {
-    mesh.isVisible = false;
-  });
-  resetManagerGizmos();
-};
-export const unhideAll = () => {
-  scene.meshes.forEach(mesh => {
-    if (!mesh.isVisible) {
-      mesh.isVisible = true;
-    }
-  });
-};
-export const deleteSelected = () => {
-  selectedMeshes.forEach(mesh => {
-    const material = mesh.material;
-    if (material?.getBindedMeshes().length === 1) {
-      const subMaterials = material.subMaterials;
-      const defaultMaterial = name => exclusionMaterials.includes(name);
-      if (subMaterials) {
-        subMaterials?.forEach(subMaterial => !defaultMaterial(subMaterial.name) && subMaterial.dispose());
-      }
-      if (!defaultMaterial(material.name)) material.dispose();
-      material.getActiveTextures().forEach(texture => texture.dispose());
-    }
-    resetManagerGizmos();
-    mesh.dispose();
-  });
-  resetSelectedMeshes();
-};
-export const toggleOrthographicViews = (e, orthoCamera) => {
-  const isDifferent = cameraView !== orthoCamera;
-  const babylonOrthographic = BABYLON.Camera.ORTHOGRAPHIC_CAMERA;
-  const babylonPerspective = BABYLON.Camera.PERSPECTIVE_CAMERA;
-  if (scene?.debugLayer.isVisible()) return;
-  if (isDifferent) {
-    cameraView = orthoCamera;
-    toggleCameraMode(orthoCamera, babylonOrthographic);
-    newMetaDataEntry('selectedOrthoView', orthoCamera);
-    return;
-  }
-  toggleCameraMode(orthoCamera, babylonPerspective);
-  newMetaDataEntry('selectedOrthoView', '');
-  cameraView = null;
-};
-export const toggleCulling = () => {
-  const materials = getUserMaterials();
-  materials.forEach(material => {
-    const isCullingBackfaces = material.backFaceCulling;
-    if (isCullingBackfaces) return material.backFaceCulling = false;
-    material.backFaceCulling = !material.backFaceCulling;
-  });
-  newMetaDataEntry('materials', buildMaterialsArray());
-  newMetaDataEntry('selectedMaterials', buildSelectedMaterialArray());
-};
-export const modelToOrigin = sourceUnitScaleOperation => {
-  const boundingBoxEnabled = gizmoManager.boundingBoxGizmoEnabled;
-  const meshes = selectedMeshes.length > 0 ? selectedMeshes : getUserMeshes();
-  const parentList = [];
-  const handleBoundingBox = () => {
-    const newBox = createBoundingMesh();
-    if (boundingBoxEnabled && !sourceUnitScaleOperation) toggleBoundingBoxWidget();
-    if (gizmoManager.boundingBoxGizmoEnabled) gizmoManager.attachToMesh(newBox);
-    resetManagerGizmos(GIZMOS.BoundingBoxGizmo);
-  };
-
-  // Single selections or only single mesh in scene.
-  if (meshes.length === 1) {
-    const mesh = meshes[0];
-    const boundingBox = mesh.getBoundingInfo().boundingBox;
-    const meshCenter = boundingBox.centerWorld;
-    const parent = mesh.parent;
-    parentList.push({
-      mesh,
-      parent
-    });
-    mesh.setParent(singleMeshTNode);
-    singleMeshTNode.position.subtractInPlace(meshCenter);
-    singleMeshTNode.position.y += boundingBox.extendSizeWorld.y;
-    selectedMeshes.length === 1 ? mesh.setParent(singleMeshTNode) : restoreParents(parentList);
-    handleBoundingBox();
-    newMetaDataEntry('meshChangeTracking', buildMeshPositionsArray({
-      preserveScale: true,
-      preserveRotation: true
-    }));
-    return;
-  }
-
-  // Multiple selections or multiple meshes in scene.
-  const multiBoundingData = getBoundingMeshData(meshes);
-  const boundingCenter = multiBoundingData.center;
-  const compensationY = multiBoundingData.maximum.y - boundingCenter.y;
-  meshes.forEach(mesh => {
-    const parent = mesh.parent;
-    parentList.push({
-      mesh,
-      parent
-    });
-    mesh.setParent(multiMeshTNode);
-  });
-  if (!sourceUnitScaleOperation) {
-    multiMeshTNode.position.subtractInPlace(boundingCenter);
-    multiMeshTNode.position.y += compensationY;
-  }
-  restoreParents(parentList);
-  handleBoundingBox();
-  newMetaDataEntry('meshChangeTracking', buildMeshPositionsArray({
-    preserveScale: true,
-    preserveRotation: true
-  }));
-};