@combeenation/3d-viewer 10.0.0-alpha3 → 10.0.0

package/src/api/util/geometryHelper.ts

@@ -1,140 +1,140 @@
-import { MorphTargetManager } from '@babylonjs/core';
-import { VertexBuffer } from '@babylonjs/core/Buffers/buffer';
-import { Vector3 } from '@babylonjs/core/Maths/math.vector';
-import type { Geometry } from '@babylonjs/core/Meshes';
-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';
-import type { FloatArray } from '@babylonjs/core/types';
-
-/**
- * Removes morph targets and sets transformation values back to their default values.
- * The effects from morph targets and tranformation values will be "baked" in the geometry, so that the final appearance
- * of the meshes stay the same.
- */
-const bakeGeometryOfAllMeshes = function (scene: Scene) {
-  // instanced meshes have to be converted, since they share the geometry of the source mesh, which would lead to issues
-  // when baking the transformation values
-  scene.meshes.forEach(mesh => {
-    if (mesh instanceof InstancedMesh) {
-      convertInstancedMeshToMesh(mesh);
-    }
-  });
-
-  // do the geometry baking for all meshes in the scene
-  scene.meshes.forEach(mesh => {
-    if (mesh instanceof Mesh) {
-      bakeGeometryOfMesh(mesh);
-    }
-  });
-
-  // some nodes (mostly transform nodes), are not affected by the baking algorithm since they have no geometry
-  // => reset their transformation manually
-  const allNodes = scene.getNodes().filter(node => node instanceof TransformNode) as TransformNode[];
-  allNodes.forEach(node => {
-    resetTransformation(node);
-  });
-};
-
-const convertInstancedMeshToMesh = function (instancedMesh: InstancedMesh) {
-  // first create a clone of the source mesh
-  const newMesh = instancedMesh.sourceMesh.clone(`${instancedMesh.name}`, instancedMesh.parent);
-  // apply the transformation data
-  newMesh.position = instancedMesh.position;
-  newMesh.rotation = instancedMesh.rotation;
-  newMesh.rotationQuaternion = instancedMesh.rotationQuaternion;
-  newMesh.scaling = instancedMesh.scaling;
-  // also sync the enabled state from the original instanced mesh
-  newMesh.setEnabled(instancedMesh.isEnabled(false));
-
-  // re-assign children of the original mesh, since that one won't be used anymore
-  instancedMesh.getChildren(undefined).forEach(childNode => (childNode.parent = newMesh));
-  // finally delete the original instanced mesh
-  instancedMesh.dispose();
-};
-
-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();
-
-  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();
-};
-
-/**
- * @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;
-};
-
-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);
-};
-
-export { bakeGeometryOfAllMeshes };
+import { MorphTargetManager } from '@babylonjs/core';
+import { VertexBuffer } from '@babylonjs/core/Buffers/buffer';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import type { Geometry } from '@babylonjs/core/Meshes';
+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';
+import type { FloatArray } from '@babylonjs/core/types';
+
+/**
+ * Removes morph targets and sets transformation values back to their default values.
+ * The effects from morph targets and tranformation values will be "baked" in the geometry, so that the final appearance
+ * of the meshes stay the same.
+ */
+const bakeGeometryOfAllMeshes = function (scene: Scene) {
+  // instanced meshes have to be converted, since they share the geometry of the source mesh, which would lead to issues
+  // when baking the transformation values
+  scene.meshes.forEach(mesh => {
+    if (mesh instanceof InstancedMesh) {
+      convertInstancedMeshToMesh(mesh);
+    }
+  });
+
+  // do the geometry baking for all meshes in the scene
+  scene.meshes.forEach(mesh => {
+    if (mesh instanceof Mesh) {
+      bakeGeometryOfMesh(mesh);
+    }
+  });
+
+  // some nodes (mostly transform nodes), are not affected by the baking algorithm since they have no geometry
+  // => reset their transformation manually
+  const allNodes = scene.getNodes().filter(node => node instanceof TransformNode) as TransformNode[];
+  allNodes.forEach(node => {
+    resetTransformation(node);
+  });
+};
+
+const convertInstancedMeshToMesh = function (instancedMesh: InstancedMesh) {
+  // first create a clone of the source mesh
+  const newMesh = instancedMesh.sourceMesh.clone(`${instancedMesh.name}`, instancedMesh.parent);
+  // apply the transformation data
+  newMesh.position = instancedMesh.position;
+  newMesh.rotation = instancedMesh.rotation;
+  newMesh.rotationQuaternion = instancedMesh.rotationQuaternion;
+  newMesh.scaling = instancedMesh.scaling;
+  // also sync the enabled state from the original instanced mesh
+  newMesh.setEnabled(instancedMesh.isEnabled(false));
+
+  // re-assign children of the original mesh, since that one won't be used anymore
+  instancedMesh.getChildren(undefined).forEach(childNode => (childNode.parent = newMesh));
+  // finally delete the original instanced mesh
+  instancedMesh.dispose();
+};
+
+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();
+
+  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();
+};
+
+/**
+ * @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;
+};
+
+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);
+};
+
+export { bakeGeometryOfAllMeshes };