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

package/src/internal/geometry-helper.ts

@@ -1,181 +1,181 @@
-import {
-  ExcludedGeometry,
-  ExcludedGeometryList,
-  FloatArray,
-  Geometry,
-  InstancedMesh,
-  Mesh,
-  MorphTarget,
-  MorphTargetManager,
-  ParameterSubject,
-  TransformNode,
-  Vector3,
-  VertexBuffer,
-} from '../index';
-import { cloneInternalMetadata } from './metadata-helper';
-import { hasTag } from './tags-helper';
-
-/**
- * Find out if a node is part of a list of excluded geometry
- * @param node BJS node
- * @param list list of excluded geometry
- * @returns boolean based on whether node (or one of its parents) was found in list
- */
-export function isNodeExcluded(nodeToCheck: TransformNode, list: ExcludedGeometryList): boolean {
-  // CAUTION: node has to be the same instance
-  const checkNode = (excludedNode: TransformNode): boolean => excludedNode === nodeToCheck;
-  const checkTagManagerSubject = (excludedSubject: ParameterSubject): boolean => {
-    const nameMatches = !!excludedSubject.nodeName && excludedSubject.nodeName === nodeToCheck.name;
-    const tagMatches = !!excludedSubject.tagName && hasTag(nodeToCheck, excludedSubject.tagName);
-    return nameMatches || tagMatches;
-  };
-  const check = (geometryToExclude: ExcludedGeometry): boolean => {
-    if (geometryToExclude instanceof TransformNode) {
-      return checkNode(geometryToExclude);
-    }
-    if ((geometryToExclude as ParameterSubject).tagName || (geometryToExclude as ParameterSubject).nodeName) {
-      return checkTagManagerSubject(geometryToExclude as ParameterSubject);
-    }
-    return false;
-  };
-
-  let isExcluded = list.some(geometryToExclude => check(geometryToExclude));
-  // consider parent as well
-  if (!isExcluded && nodeToCheck.parent instanceof TransformNode) {
-    isExcluded = isNodeExcluded(nodeToCheck.parent, list);
-  }
-
-  return isExcluded;
-}
-
-/**
- * Creates a "standard" mesh from an instanced mesh, by cloning the source mesh and applying transformation data
- */
-export function createMeshFromInstancedMesh(
-  instancedMesh: InstancedMesh,
-  newName: string,
-  clonedParent: TransformNode
-): Mesh {
-  // first create a clone of the source mesh
-  const newMesh = instancedMesh.sourceMesh.clone(newName, clonedParent, true);
-  cloneInternalMetadata(instancedMesh.sourceMesh, newMesh);
-  // 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.
- */
-export function bakeGeometryOfMesh(mesh: Mesh): void {
-  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
- */
-export function resetTransformation(node: TransformNode): void {
-  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
- */
-function _bakeMorphTargetManagerIntoVertices(
-  kind: string,
-  morphTargetManager: MorphTargetManager,
-  geometry: Geometry
-): void {
-  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);
-}
-
-function _getVerticesDataFromMorphTarget(kind: string, morphTarget: MorphTarget): FloatArray | null {
-  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;
-}
+import {
+  ExcludedGeometry,
+  ExcludedGeometryList,
+  FloatArray,
+  Geometry,
+  InstancedMesh,
+  Mesh,
+  MorphTarget,
+  MorphTargetManager,
+  ParameterSubject,
+  TransformNode,
+  Vector3,
+  VertexBuffer,
+} from '../index';
+import { cloneInternalMetadata } from './metadata-helper';
+import { hasTag } from './tags-helper';
+
+/**
+ * Find out if a node is part of a list of excluded geometry
+ * @param node BJS node
+ * @param list list of excluded geometry
+ * @returns boolean based on whether node (or one of its parents) was found in list
+ */
+export function isNodeExcluded(nodeToCheck: TransformNode, list: ExcludedGeometryList): boolean {
+  // CAUTION: node has to be the same instance
+  const checkNode = (excludedNode: TransformNode): boolean => excludedNode === nodeToCheck;
+  const checkTagManagerSubject = (excludedSubject: ParameterSubject): boolean => {
+    const nameMatches = !!excludedSubject.nodeName && excludedSubject.nodeName === nodeToCheck.name;
+    const tagMatches = !!excludedSubject.tagName && hasTag(nodeToCheck, excludedSubject.tagName);
+    return nameMatches || tagMatches;
+  };
+  const check = (geometryToExclude: ExcludedGeometry): boolean => {
+    if (geometryToExclude instanceof TransformNode) {
+      return checkNode(geometryToExclude);
+    }
+    if ((geometryToExclude as ParameterSubject).tagName || (geometryToExclude as ParameterSubject).nodeName) {
+      return checkTagManagerSubject(geometryToExclude as ParameterSubject);
+    }
+    return false;
+  };
+
+  let isExcluded = list.some(geometryToExclude => check(geometryToExclude));
+  // consider parent as well
+  if (!isExcluded && nodeToCheck.parent instanceof TransformNode) {
+    isExcluded = isNodeExcluded(nodeToCheck.parent, list);
+  }
+
+  return isExcluded;
+}
+
+/**
+ * Creates a "standard" mesh from an instanced mesh, by cloning the source mesh and applying transformation data
+ */
+export function createMeshFromInstancedMesh(
+  instancedMesh: InstancedMesh,
+  newName: string,
+  clonedParent: TransformNode
+): Mesh {
+  // first create a clone of the source mesh
+  const newMesh = instancedMesh.sourceMesh.clone(newName, clonedParent, true);
+  cloneInternalMetadata(instancedMesh.sourceMesh, newMesh);
+  // 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.
+ */
+export function bakeGeometryOfMesh(mesh: Mesh): void {
+  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
+ */
+export function resetTransformation(node: TransformNode): void {
+  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
+ */
+function _bakeMorphTargetManagerIntoVertices(
+  kind: string,
+  morphTargetManager: MorphTargetManager,
+  geometry: Geometry
+): void {
+  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);
+}
+
+function _getVerticesDataFromMorphTarget(kind: string, morphTarget: MorphTarget): FloatArray | null {
+  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;
+}

package/src/internal/metadata-helper.ts

@@ -1,63 +1,63 @@
-import { BaseTexture, Material, Node } from '../index';
-import { cloneDeep } from 'lodash-es';
-
-type MetadataValue = string | number | boolean | undefined;
-type MetadataTarget = Node | Material | BaseTexture;
-type MetadataKeys =
-  // CBN babylon loader
-  | 'deferredMaterial'
-  // material manager
-  | 'materialToBeSet'
-  // GLTF export
-  | 'exportNode'
-  | 'deleteAfterExport'
-  | 'exchangeMaterialWith'
-  // cloning
-  | 'cloneSource'
-  | 'cloneTarget';
-
-// TODO WTT: use generics or some kind of logic that is able to type the metadata according to their key
-/**
- * Sets certain metadata on the objects INTERNAL metadata storage.
- * "object._internalMetadata.cbn" is reserved for CBN specific metadata information.
- * The objects public metadata ("object.metadata") is not affected and should therefore not interfere with metadata
- * that is used in consumer projects.
- */
-export function setInternalMetadataValue(object: MetadataTarget, key: MetadataKeys, value: MetadataValue): void {
-  if (!object._internalMetadata) {
-    object._internalMetadata = {};
-  }
-  if (!object._internalMetadata.cbn) {
-    object._internalMetadata.cbn = {};
-  }
-
-  object._internalMetadata.cbn[key] = value;
-}
-
-export function clearInternalMetadataValue(object: MetadataTarget, key: MetadataKeys): void {
-  delete object._internalMetadata?.cbn?.[key];
-}
-
-export function getInternalMetadataValue(object: MetadataTarget, key: MetadataKeys): MetadataValue {
-  return object._internalMetadata?.cbn?.[key];
-}
-
-/**
- * Creates a deep clone from the source objects internal metadata and assigns it to the target objects metadata.
- * This is required as Babylon.js only creates shallow clones of the internal metadata, which would be problematic for
- * our needs.
- */
-export function cloneInternalMetadata(sourceObject: MetadataTarget, targetObject: MetadataTarget): void {
-  targetObject._internalMetadata = cloneDeep(sourceObject._internalMetadata);
-}
-
-/**
- * Clones the metadata from one object to another.
- * CAUTION: this is now the public available "object.metadata" object.
- * We need this function internally when cloning instanced meshes.
- */
-export function cloneMetadata(sourceObject: MetadataTarget, targetObject: MetadataTarget): void {
-  const clonedMetadata = cloneDeep(sourceObject.metadata);
-
-  targetObject.metadata = clonedMetadata;
-}
+import { BaseTexture, Material, Node } from '../index';
+import { cloneDeep } from 'lodash-es';
+
+type MetadataValue = string | number | boolean | undefined;
+type MetadataTarget = Node | Material | BaseTexture;
+type MetadataKeys =
+  // CBN babylon loader
+  | 'deferredMaterial'
+  // material manager
+  | 'materialToBeSet'
+  // GLTF export
+  | 'exportNode'
+  | 'deleteAfterExport'
+  | 'exchangeMaterialWith'
+  // cloning
+  | 'cloneSource'
+  | 'cloneTarget';
+
+// TODO WTT: use generics or some kind of logic that is able to type the metadata according to their key
+/**
+ * Sets certain metadata on the objects INTERNAL metadata storage.
+ * "object._internalMetadata.cbn" is reserved for CBN specific metadata information.
+ * The objects public metadata ("object.metadata") is not affected and should therefore not interfere with metadata
+ * that is used in consumer projects.
+ */
+export function setInternalMetadataValue(object: MetadataTarget, key: MetadataKeys, value: MetadataValue): void {
+  if (!object._internalMetadata) {
+    object._internalMetadata = {};
+  }
+  if (!object._internalMetadata.cbn) {
+    object._internalMetadata.cbn = {};
+  }
+
+  object._internalMetadata.cbn[key] = value;
+}
+
+export function clearInternalMetadataValue(object: MetadataTarget, key: MetadataKeys): void {
+  delete object._internalMetadata?.cbn?.[key];
+}
+
+export function getInternalMetadataValue(object: MetadataTarget, key: MetadataKeys): MetadataValue {
+  return object._internalMetadata?.cbn?.[key];
+}
+
+/**
+ * Creates a deep clone from the source objects internal metadata and assigns it to the target objects metadata.
+ * This is required as Babylon.js only creates shallow clones of the internal metadata, which would be problematic for
+ * our needs.
+ */
+export function cloneInternalMetadata(sourceObject: MetadataTarget, targetObject: MetadataTarget): void {
+  targetObject._internalMetadata = cloneDeep(sourceObject._internalMetadata);
+}
+
+/**
+ * Clones the metadata from one object to another.
+ * CAUTION: this is now the public available "object.metadata" object.
+ * We need this function internally when cloning instanced meshes.
+ */
+export function cloneMetadata(sourceObject: MetadataTarget, targetObject: MetadataTarget): void {
+  const clonedMetadata = cloneDeep(sourceObject.metadata);
+
+  targetObject.metadata = clonedMetadata;
+}