@combeenation/3d-viewer 12.4.1 → 12.4.3

package/src/api/util/debugHelper.ts

@@ -1,121 +1,121 @@
-import { AxesViewer } from '@babylonjs/core/Debug/axesViewer';
-import { DynamicTexture } from '@babylonjs/core/Materials/Textures/dynamicTexture';
-import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
-import { Color3 } from '@babylonjs/core/Maths/math.color';
-import { Vector3 } from '@babylonjs/core/Maths/math.vector';
-import { MeshBuilder } from '@babylonjs/core/Meshes/meshBuilder';
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import { UtilityLayerRenderer } from '@babylonjs/core/Rendering/utilityLayerRenderer';
-
-type DebugAxisKeys = 'X' | 'Y' | 'Z';
-type DebugAxisConfig = { color: Color3; position: Vector3 };
-
-const _DEBUG_AXIS_MAP: Record<DebugAxisKeys, DebugAxisConfig> = {
-  X: { color: Color3.Red().scale(0.5), position: new Vector3(1, 0, 0) },
-  Y: { color: Color3.Green().scale(0.5), position: new Vector3(0, 1, 0) },
-  Z: { color: Color3.Blue().scale(0.5), position: new Vector3(0, 0, 1) },
-};
-
-const _WORLD_COORD_ROOT_KEY = '__world_coordinates__';
-let _AXES_VIEWER: AxesViewer;
-
-/**
- * Create debug coordinate system located in world origin.
- * This function is based on Babylon.js `AxesViewer`, axis texts are added manually.
- */
-export function showWorldCoordinates(dimension: number) {
-  // make sure to remove already existing debug coordinate systems
-  hideWorldCoordinates();
-
-  // draw in utility layer, so that there is no interaction with the actually scene content (eg: glb export, autofocus)
-  const utilityLayerScene = UtilityLayerRenderer.DefaultUtilityLayer.utilityLayerScene;
-
-  const worldCoordRoot = new TransformNode('__world_coordinates__', utilityLayerScene);
-  // axes viewer coordinate system is a bit too large
-  // multiply with unify factor to create arrows which exactly match the length of the input dimension
-  const factor = _getWorldCoordinatesAxesUnifyFactor();
-  _AXES_VIEWER = new AxesViewer(utilityLayerScene, dimension * factor);
-
-  _prepareWorldCoordinateAxis('X', _AXES_VIEWER.xAxis, worldCoordRoot, dimension, utilityLayerScene);
-  _prepareWorldCoordinateAxis('Y', _AXES_VIEWER.yAxis, worldCoordRoot, dimension, utilityLayerScene);
-  _prepareWorldCoordinateAxis('Z', _AXES_VIEWER.zAxis, worldCoordRoot, dimension, utilityLayerScene);
-}
-
-/**
- * Remove meshes and materials that are associated with the debug world coordinates system
- */
-export function hideWorldCoordinates() {
-  const utilityLayerScene = UtilityLayerRenderer.DefaultUtilityLayer.utilityLayerScene;
-
-  _AXES_VIEWER?.dispose();
-
-  const worldCoordRoot = utilityLayerScene.getTransformNodeByName(_WORLD_COORD_ROOT_KEY);
-  if (worldCoordRoot) {
-    worldCoordRoot.dispose(false, true);
-  }
-}
-
-/**
- * Adjust and enhance coordinate axes to fulfill our needs.
- * - moves nodes into common root
- * - adds text node
- */
-function _prepareWorldCoordinateAxis(
-  text: 'X' | 'Y' | 'Z',
-  axis: TransformNode,
-  root: TransformNode,
-  dimension: number,
-  utilityLayerScene: Scene
-) {
-  // create unique names
-  axis.name = `${_WORLD_COORD_ROOT_KEY}.${text}`;
-  axis.parent = root;
-
-  // create text mesh via dynamic texture
-  const dynamicTexture = new DynamicTexture(`${_WORLD_COORD_ROOT_KEY}.${text}`, 50, utilityLayerScene, true);
-  dynamicTexture.hasAlpha = true;
-  // 42.5 is a magic offset, so that the text is vertically centered for font size 50px
-  // horizontal centering works well with the standard behaviour of Babylon.js (setting "null" as "width")
-  dynamicTexture.drawText(text, null, 42.5, 'bold 50px Arial', 'white', 'transparent', true);
-
-  const material = new StandardMaterial(`${_WORLD_COORD_ROOT_KEY}.${text}`, utilityLayerScene);
-  material.disableLighting = true;
-  material.emissiveColor = _DEBUG_AXIS_MAP[text].color;
-  material.diffuseTexture = dynamicTexture;
-
-  const plane = MeshBuilder.CreatePlane(
-    `${_WORLD_COORD_ROOT_KEY}.${text}.TextPlane`,
-    { size: dimension / 10 },
-    utilityLayerScene
-  );
-  // make sure that text is located outside of arrow
-  plane.position = _DEBUG_AXIS_MAP[text].position.multiplyByFloats(
-    dimension * 1.05,
-    dimension * 1.05,
-    dimension * 1.05
-  );
-  plane.parent = root;
-  plane.material = material;
-  // will be rendered on top of "default" meshes => taken from Babylon.js repo "AxesViewer" implementation
-  plane.renderingGroupId = 2;
-  // setting billboard mode ensures, that the text is always readable
-  plane.billboardMode = TransformNode.BILLBOARDMODE_ALL;
-}
-
-/**
- * Calculate factor for creating world coordinate axes with exactly one unit in length
- */
-function _getWorldCoordinatesAxesUnifyFactor() {
-  // These constants are taken from the Babylon.js repository
-  const coneZPosOffset = 0.3;
-  const coneHeight = 0.075;
-  const baseScaling = 4;
-
-  // cone is moved 0.3 units away from the center
-  // the origin of the cone will be located on 1.2, if combined with the base scaling of 4
-  // invert that offset to get the origin to 1
-  // also consider the cone height to move the tip of the cone to 1 instead the center
-  const factor = 1 / ((coneZPosOffset + coneHeight / 2) * baseScaling);
-
-  return factor;
-}
+import { AxesViewer } from '@babylonjs/core/Debug/axesViewer';
+import { DynamicTexture } from '@babylonjs/core/Materials/Textures/dynamicTexture';
+import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
+import { Color3 } from '@babylonjs/core/Maths/math.color';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import { MeshBuilder } from '@babylonjs/core/Meshes/meshBuilder';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { UtilityLayerRenderer } from '@babylonjs/core/Rendering/utilityLayerRenderer';
+
+type DebugAxisKeys = 'X' | 'Y' | 'Z';
+type DebugAxisConfig = { color: Color3; position: Vector3 };
+
+const _DEBUG_AXIS_MAP: Record<DebugAxisKeys, DebugAxisConfig> = {
+  X: { color: Color3.Red().scale(0.5), position: new Vector3(1, 0, 0) },
+  Y: { color: Color3.Green().scale(0.5), position: new Vector3(0, 1, 0) },
+  Z: { color: Color3.Blue().scale(0.5), position: new Vector3(0, 0, 1) },
+};
+
+const _WORLD_COORD_ROOT_KEY = '__world_coordinates__';
+let _AXES_VIEWER: AxesViewer;
+
+/**
+ * Create debug coordinate system located in world origin.
+ * This function is based on Babylon.js `AxesViewer`, axis texts are added manually.
+ */
+export function showWorldCoordinates(dimension: number) {
+  // make sure to remove already existing debug coordinate systems
+  hideWorldCoordinates();
+
+  // draw in utility layer, so that there is no interaction with the actually scene content (eg: glb export, autofocus)
+  const utilityLayerScene = UtilityLayerRenderer.DefaultUtilityLayer.utilityLayerScene;
+
+  const worldCoordRoot = new TransformNode('__world_coordinates__', utilityLayerScene);
+  // axes viewer coordinate system is a bit too large
+  // multiply with unify factor to create arrows which exactly match the length of the input dimension
+  const factor = _getWorldCoordinatesAxesUnifyFactor();
+  _AXES_VIEWER = new AxesViewer(utilityLayerScene, dimension * factor);
+
+  _prepareWorldCoordinateAxis('X', _AXES_VIEWER.xAxis, worldCoordRoot, dimension, utilityLayerScene);
+  _prepareWorldCoordinateAxis('Y', _AXES_VIEWER.yAxis, worldCoordRoot, dimension, utilityLayerScene);
+  _prepareWorldCoordinateAxis('Z', _AXES_VIEWER.zAxis, worldCoordRoot, dimension, utilityLayerScene);
+}
+
+/**
+ * Remove meshes and materials that are associated with the debug world coordinates system
+ */
+export function hideWorldCoordinates() {
+  const utilityLayerScene = UtilityLayerRenderer.DefaultUtilityLayer.utilityLayerScene;
+
+  _AXES_VIEWER?.dispose();
+
+  const worldCoordRoot = utilityLayerScene.getTransformNodeByName(_WORLD_COORD_ROOT_KEY);
+  if (worldCoordRoot) {
+    worldCoordRoot.dispose(false, true);
+  }
+}
+
+/**
+ * Adjust and enhance coordinate axes to fulfill our needs.
+ * - moves nodes into common root
+ * - adds text node
+ */
+function _prepareWorldCoordinateAxis(
+  text: 'X' | 'Y' | 'Z',
+  axis: TransformNode,
+  root: TransformNode,
+  dimension: number,
+  utilityLayerScene: Scene
+) {
+  // create unique names
+  axis.name = `${_WORLD_COORD_ROOT_KEY}.${text}`;
+  axis.parent = root;
+
+  // create text mesh via dynamic texture
+  const dynamicTexture = new DynamicTexture(`${_WORLD_COORD_ROOT_KEY}.${text}`, 50, utilityLayerScene, true);
+  dynamicTexture.hasAlpha = true;
+  // 42.5 is a magic offset, so that the text is vertically centered for font size 50px
+  // horizontal centering works well with the standard behaviour of Babylon.js (setting "null" as "width")
+  dynamicTexture.drawText(text, null, 42.5, 'bold 50px Arial', 'white', 'transparent', true);
+
+  const material = new StandardMaterial(`${_WORLD_COORD_ROOT_KEY}.${text}`, utilityLayerScene);
+  material.disableLighting = true;
+  material.emissiveColor = _DEBUG_AXIS_MAP[text].color;
+  material.diffuseTexture = dynamicTexture;
+
+  const plane = MeshBuilder.CreatePlane(
+    `${_WORLD_COORD_ROOT_KEY}.${text}.TextPlane`,
+    { size: dimension / 10 },
+    utilityLayerScene
+  );
+  // make sure that text is located outside of arrow
+  plane.position = _DEBUG_AXIS_MAP[text].position.multiplyByFloats(
+    dimension * 1.05,
+    dimension * 1.05,
+    dimension * 1.05
+  );
+  plane.parent = root;
+  plane.material = material;
+  // will be rendered on top of "default" meshes => taken from Babylon.js repo "AxesViewer" implementation
+  plane.renderingGroupId = 2;
+  // setting billboard mode ensures, that the text is always readable
+  plane.billboardMode = TransformNode.BILLBOARDMODE_ALL;
+}
+
+/**
+ * Calculate factor for creating world coordinate axes with exactly one unit in length
+ */
+function _getWorldCoordinatesAxesUnifyFactor() {
+  // These constants are taken from the Babylon.js repository
+  const coneZPosOffset = 0.3;
+  const coneHeight = 0.075;
+  const baseScaling = 4;
+
+  // cone is moved 0.3 units away from the center
+  // the origin of the cone will be located on 1.2, if combined with the base scaling of 4
+  // invert that offset to get the origin to 1
+  // also consider the cone height to move the tip of the cone to 1 instead the center
+  const factor = 1 / ((coneZPosOffset + coneHeight / 2) * baseScaling);
+
+  return factor;
+}

package/src/api/util/deviceHelper.ts

@@ -1,31 +1,31 @@
-import { SpecStorage } from '../store/specStorage';
-
-/**
- * Checks if the current device is an iPhone
- */
-const getIsIPhone = () => {
-  const isIPhone = /iPhone/.test(navigator.userAgent);
-
-  return isIPhone;
-};
-
-/**
- * Checks if the current device is "scaled down", as defined in the Spec
- */
-const getIsScaledDownDevice = () => {
-  const sceneJson = SpecStorage.get<SceneJson>('scene');
-
-  if (!sceneJson.engine?.limitTextureSize) {
-    // no down scaling defined
-    return false;
-  }
-
-  // check device
-  const deviceFits =
-    sceneJson.engine.limitTextureSize.devices === 'all' ||
-    (sceneJson.engine.limitTextureSize.devices === 'iPhone' && getIsIPhone());
-
-  return deviceFits;
-};
-
-export { getIsIPhone, getIsScaledDownDevice };
+import { SpecStorage } from '../store/specStorage';
+
+/**
+ * Checks if the current device is an iPhone
+ */
+const getIsIPhone = () => {
+  const isIPhone = /iPhone/.test(navigator.userAgent);
+
+  return isIPhone;
+};
+
+/**
+ * Checks if the current device is "scaled down", as defined in the Spec
+ */
+const getIsScaledDownDevice = () => {
+  const sceneJson = SpecStorage.get<SceneJson>('scene');
+
+  if (!sceneJson.engine?.limitTextureSize) {
+    // no down scaling defined
+    return false;
+  }
+
+  // check device
+  const deviceFits =
+    sceneJson.engine.limitTextureSize.devices === 'all' ||
+    (sceneJson.engine.limitTextureSize.devices === 'iPhone' && getIsIPhone());
+
+  return deviceFits;
+};
+
+export { getIsIPhone, getIsScaledDownDevice };

package/src/api/util/geometryHelper.ts

@@ -1,142 +1,142 @@
-import { VertexBuffer } from '@babylonjs/core/Buffers/buffer';
-import { Vector3 } from '@babylonjs/core/Maths/math.vector';
-import type { Geometry } from '@babylonjs/core/Meshes/geometry';
-import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh';
-import { Mesh } from '@babylonjs/core/Meshes/mesh';
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-import type { MorphTarget } from '@babylonjs/core/Morph/morphTarget';
-import { MorphTargetManager } from '@babylonjs/core/Morph/morphTargetManager';
-import type { FloatArray } from '@babylonjs/core/types';
-
-/**
- * Creates a "standard" mesh from an instanced mesh, by cloning the source mesh and applying transformation data
- */
-const createMeshFromInstancedMesh = function (
-  instancedMesh: InstancedMesh,
-  newName: string,
-  clonedParent: Nullable<TransformNode>
-) {
-  // first create a clone of the source mesh
-  const newMesh = instancedMesh.sourceMesh.clone(newName, clonedParent, true);
-  // apply the transformation data, it's important to create clones of the transformations to not touch the original
-  // transformation when applying changes (eg: geometry baking)
-  newMesh.position = instancedMesh.position.clone();
-  newMesh.rotation = instancedMesh.rotation.clone();
-  newMesh.scaling = instancedMesh.scaling.clone();
-
-  // rotation quaternion is optional
-  if (instancedMesh.rotationQuaternion) {
-    newMesh.rotationQuaternion = instancedMesh.rotationQuaternion.clone();
-  }
-
-  // also sync the enabled state from the original instanced mesh
-  newMesh.setEnabled(instancedMesh.isEnabled(false));
-
-  return newMesh;
-};
-
-/**
- * Removes transformation data from the mesh and stores it in the geometry, which is called "baking".
- * Also considers the geometry change from morph targets.
- */
-const bakeGeometryOfMesh = function (mesh: Mesh) {
-  if (!mesh.geometry) {
-    // no geometry available, nothing to do
-    return;
-  }
-
-  // geometries can be shared across multiple meshes, first make them unique to avoid side-effects
-  mesh.makeGeometryUnique();
-
-  // Babylon.js already provides a function for baking the current skeleton changes into the geometry
-  if (mesh.skeleton) {
-    mesh.applySkeleton(mesh.skeleton);
-    mesh.skeleton = null;
-  }
-
-  // NOTE: in difference to skeletons and transformations there is no baking function for morph targets (yet)
-  // however another approach could be to re-apply the position and normals data, as there are nice functions for it
-  // - `getPositionData(applySkeleton: boolean = false, applyMorph: boolean = false)`
-  // - `getNormalsData(applySkeleton: boolean = false, applyMorph: boolean = false)`
-  // you can decide if skeletons and morph targets can be added, which is exactly what we want
-  // I'm still hesitant to use it because "tangent" and "UV" kinds are not supported, whereas I'm not sure if it's
-  // required
-  // => try it out when there is enough time for detailed regression tests!
-  const morphTargetManager = mesh.morphTargetManager;
-  const geometry = mesh.geometry;
-
-  if (morphTargetManager?.numTargets) {
-    // apply morph target vertices data to mesh geometry
-    // mostly only the "PositionKind" is implemented
-    _bakeMorphTargetManagerIntoVertices(VertexBuffer.PositionKind, morphTargetManager, geometry);
-    _bakeMorphTargetManagerIntoVertices(VertexBuffer.NormalKind, morphTargetManager, geometry);
-    _bakeMorphTargetManagerIntoVertices(VertexBuffer.TangentKind, morphTargetManager, geometry);
-    _bakeMorphTargetManagerIntoVertices(VertexBuffer.UVKind, morphTargetManager, geometry);
-
-    // remove morph target manager with all it's morph targets
-    mesh.morphTargetManager = null;
-  }
-
-  // bake the transformation data in the mesh geometry, fortunately there is already a help function from Babylon.js
-  mesh.bakeCurrentTransformIntoVertices();
-};
-
-/**
- * Resets transformation to initial state
- */
-const resetTransformation = function (node: TransformNode) {
-  node.position = new Vector3(0, 0, 0);
-  node.rotation = new Vector3(0, 0, 0);
-  node.rotationQuaternion = null;
-  node.scaling = new Vector3(1, 1, 1);
-};
-
-/**
- * @param kind morph targets can affect various vertices kinds, whereas "position" is the most common one
- * still other kinds (like normals or tangents) can be affected as well and can be provided on this input
- */
-const _bakeMorphTargetManagerIntoVertices = function (
-  kind: string,
-  morphTargetManager: MorphTargetManager,
-  geometry: Geometry
-) {
-  const origVerticesData = geometry.getVerticesData(kind);
-  if (!origVerticesData) {
-    // no vertices data for this kind availabe on the mesh geometry
-    return;
-  }
-
-  let verticesData = [...origVerticesData];
-  for (let i = 0; i < morphTargetManager.numTargets; i++) {
-    const target = morphTargetManager.getTarget(i);
-    const targetVerticesData = _getVerticesDataFromMorphTarget(kind, target);
-    if (targetVerticesData) {
-      // vertices data of this kind are implemented on the morph target
-      // add the influence of this morph target to the vertices data
-      // formula is taken from: https://doc.babylonjs.com/features/featuresDeepDive/mesh/morphTargets#basics
-      verticesData = verticesData.map(
-        (oldVal, idx) => oldVal + (targetVerticesData[idx] - origVerticesData[idx]) * target.influence
-      );
-    }
-  }
-
-  // apply the updated vertices data
-  geometry.setVerticesData(kind, verticesData);
-};
-
-const _getVerticesDataFromMorphTarget = function (kind: string, morphTarget: MorphTarget): Nullable<FloatArray> {
-  switch (kind) {
-    case VertexBuffer.PositionKind:
-      return morphTarget.getPositions();
-    case VertexBuffer.NormalKind:
-      return morphTarget.getNormals();
-    case VertexBuffer.TangentKind:
-      return morphTarget.getTangents();
-    case VertexBuffer.UVKind:
-      return morphTarget.getUVs();
-  }
-
-  return null;
-};
-
-export { createMeshFromInstancedMesh, bakeGeometryOfMesh, resetTransformation };
+import { VertexBuffer } from '@babylonjs/core/Buffers/buffer';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import type { Geometry } from '@babylonjs/core/Meshes/geometry';
+import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import type { MorphTarget } from '@babylonjs/core/Morph/morphTarget';
+import { MorphTargetManager } from '@babylonjs/core/Morph/morphTargetManager';
+import type { FloatArray } from '@babylonjs/core/types';
+
+/**
+ * Creates a "standard" mesh from an instanced mesh, by cloning the source mesh and applying transformation data
+ */
+const createMeshFromInstancedMesh = function (
+  instancedMesh: InstancedMesh,
+  newName: string,
+  clonedParent: Nullable<TransformNode>
+) {
+  // first create a clone of the source mesh
+  const newMesh = instancedMesh.sourceMesh.clone(newName, clonedParent, true);
+  // apply the transformation data, it's important to create clones of the transformations to not touch the original
+  // transformation when applying changes (eg: geometry baking)
+  newMesh.position = instancedMesh.position.clone();
+  newMesh.rotation = instancedMesh.rotation.clone();
+  newMesh.scaling = instancedMesh.scaling.clone();
+
+  // rotation quaternion is optional
+  if (instancedMesh.rotationQuaternion) {
+    newMesh.rotationQuaternion = instancedMesh.rotationQuaternion.clone();
+  }
+
+  // also sync the enabled state from the original instanced mesh
+  newMesh.setEnabled(instancedMesh.isEnabled(false));
+
+  return newMesh;
+};
+
+/**
+ * Removes transformation data from the mesh and stores it in the geometry, which is called "baking".
+ * Also considers the geometry change from morph targets.
+ */
+const bakeGeometryOfMesh = function (mesh: Mesh) {
+  if (!mesh.geometry) {
+    // no geometry available, nothing to do
+    return;
+  }
+
+  // geometries can be shared across multiple meshes, first make them unique to avoid side-effects
+  mesh.makeGeometryUnique();
+
+  // Babylon.js already provides a function for baking the current skeleton changes into the geometry
+  if (mesh.skeleton) {
+    mesh.applySkeleton(mesh.skeleton);
+    mesh.skeleton = null;
+  }
+
+  // NOTE: in difference to skeletons and transformations there is no baking function for morph targets (yet)
+  // however another approach could be to re-apply the position and normals data, as there are nice functions for it
+  // - `getPositionData(applySkeleton: boolean = false, applyMorph: boolean = false)`
+  // - `getNormalsData(applySkeleton: boolean = false, applyMorph: boolean = false)`
+  // you can decide if skeletons and morph targets can be added, which is exactly what we want
+  // I'm still hesitant to use it because "tangent" and "UV" kinds are not supported, whereas I'm not sure if it's
+  // required
+  // => try it out when there is enough time for detailed regression tests!
+  const morphTargetManager = mesh.morphTargetManager;
+  const geometry = mesh.geometry;
+
+  if (morphTargetManager?.numTargets) {
+    // apply morph target vertices data to mesh geometry
+    // mostly only the "PositionKind" is implemented
+    _bakeMorphTargetManagerIntoVertices(VertexBuffer.PositionKind, morphTargetManager, geometry);
+    _bakeMorphTargetManagerIntoVertices(VertexBuffer.NormalKind, morphTargetManager, geometry);
+    _bakeMorphTargetManagerIntoVertices(VertexBuffer.TangentKind, morphTargetManager, geometry);
+    _bakeMorphTargetManagerIntoVertices(VertexBuffer.UVKind, morphTargetManager, geometry);
+
+    // remove morph target manager with all it's morph targets
+    mesh.morphTargetManager = null;
+  }
+
+  // bake the transformation data in the mesh geometry, fortunately there is already a help function from Babylon.js
+  mesh.bakeCurrentTransformIntoVertices();
+};
+
+/**
+ * Resets transformation to initial state
+ */
+const resetTransformation = function (node: TransformNode) {
+  node.position = new Vector3(0, 0, 0);
+  node.rotation = new Vector3(0, 0, 0);
+  node.rotationQuaternion = null;
+  node.scaling = new Vector3(1, 1, 1);
+};
+
+/**
+ * @param kind morph targets can affect various vertices kinds, whereas "position" is the most common one
+ * still other kinds (like normals or tangents) can be affected as well and can be provided on this input
+ */
+const _bakeMorphTargetManagerIntoVertices = function (
+  kind: string,
+  morphTargetManager: MorphTargetManager,
+  geometry: Geometry
+) {
+  const origVerticesData = geometry.getVerticesData(kind);
+  if (!origVerticesData) {
+    // no vertices data for this kind availabe on the mesh geometry
+    return;
+  }
+
+  let verticesData = [...origVerticesData];
+  for (let i = 0; i < morphTargetManager.numTargets; i++) {
+    const target = morphTargetManager.getTarget(i);
+    const targetVerticesData = _getVerticesDataFromMorphTarget(kind, target);
+    if (targetVerticesData) {
+      // vertices data of this kind are implemented on the morph target
+      // add the influence of this morph target to the vertices data
+      // formula is taken from: https://doc.babylonjs.com/features/featuresDeepDive/mesh/morphTargets#basics
+      verticesData = verticesData.map(
+        (oldVal, idx) => oldVal + (targetVerticesData[idx] - origVerticesData[idx]) * target.influence
+      );
+    }
+  }
+
+  // apply the updated vertices data
+  geometry.setVerticesData(kind, verticesData);
+};
+
+const _getVerticesDataFromMorphTarget = function (kind: string, morphTarget: MorphTarget): Nullable<FloatArray> {
+  switch (kind) {
+    case VertexBuffer.PositionKind:
+      return morphTarget.getPositions();
+    case VertexBuffer.NormalKind:
+      return morphTarget.getNormals();
+    case VertexBuffer.TangentKind:
+      return morphTarget.getTangents();
+    case VertexBuffer.UVKind:
+      return morphTarget.getUVs();
+  }
+
+  return null;
+};
+
+export { createMeshFromInstancedMesh, bakeGeometryOfMesh, resetTransformation };