@combeenation/3d-viewer 12.0.0-alpha1 → 12.0.0-alpha3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@combeenation/3d-viewer",
-  "version": "12.0.0-alpha1",
+  "version": "12.0.0-alpha3",
   "description": "Combeenation 3D Viewer",
   "homepage": "https://github.com/Combeenation/3d-viewer#readme",
   "bugs": {

package/src/api/manager/gltfExportManager.ts

@@ -59,26 +59,31 @@ export class GltfExportManager {
   }
 
   protected async _exportPreProcess(excluded?: ExcludedGeometryList): Promise<void> {
+    this.viewer.pauseRendering();
+
     // handle materials
     this.viewer.scene.materials
       .filter(material => this._shouldReplaceMaterial(material))
       .forEach(material => this._createRefractionMaterialReplacement(material as PBRMaterial));
 
     // handle nodes
-    this.viewer.scene.rootNodes.forEach(rootNode =>
-      this._prepareNodeForExport(rootNode as TransformNode, null, excluded)
-    );
+    this.viewer.scene.rootNodes.forEach(rootNode => this._prepareNodeForExport(rootNode, null, excluded));
+
+    // bake transformation of all meshes, so that no negative scalings are left
+    // it's important that this is done AFTER instanced meshes have been converted (_prepareNodeForExport)
+    this.viewer.scene.meshes
+      .filter(mesh => !!mesh.metadata?.[GltfExportManager._METADATA_PROPS.exportNode])
+      .forEach(mesh => bakeGeometryOfMesh(mesh as Mesh));
 
     // reset transformation of all "TransformNodes", which couldn't be handled by the geometry baking algorithm
     // it's important that this is done AFTER all geometries have been baked
-    this.viewer.scene
-      .getNodes()
+    [...this.viewer.scene.transformNodes, ...this.viewer.scene.meshes]
       .filter(node => !!node.metadata?.[GltfExportManager._METADATA_PROPS.exportNode])
       .forEach(node => resetTransformation(node as TransformNode));
   }
 
   protected async _exportPostProcess(): Promise<void> {
-    // dispose all nodes and material that have only been created for the export
+    // dispose all nodes and materials that have only been created for the export
     this.viewer.scene.rootNodes
       .filter(rootNode => rootNode.metadata?.[GltfExportManager._METADATA_PROPS.deleteAfterExport])
       .forEach(rootNode => rootNode.dispose());
@@ -86,6 +91,8 @@ export class GltfExportManager {
     this.viewer.scene.materials
       .filter(mat => !!mat.metadata?.[GltfExportManager._METADATA_PROPS.deleteAfterExport])
       .forEach(material => material.dispose(false, false));
+
+    this.viewer.resumeRendering();
   }
 
   protected _gltfExportOptions(): IExportOptions {
@@ -95,13 +102,13 @@ export class GltfExportManager {
       },
       // keep root node(s)
       // this seems to be important due to the geometry baking and transformation resetting stuff
-      // => root node has no transformation anymore, which seems to be problematic for the import
+      // => root node would have no transformation anymore, which seems to be problematic for the import
       removeNoopRootNodes: false,
     };
   }
 
   protected _prepareNodeForExport(
-    node: TransformNode,
+    node: BjsNode,
     clonedParent: Nullable<TransformNode>,
     excluded?: ExcludedGeometryList
   ) {
@@ -109,17 +116,18 @@ export class GltfExportManager {
       return;
     }
 
+    // from here on we only have TransformNodes
+    const transformNode = node as TransformNode;
+
     // clone original node and create unique name (via uniqueId)
-    const newNodeName = `${node.name}_${node.uniqueId}`;
+    const newNodeName = `${transformNode.name}_${transformNode.uniqueId}`;
     const clonedNode =
-      node instanceof InstancedMesh
-        ? createMeshFromInstancedMesh(node, newNodeName)
-        : node.clone(newNodeName, clonedParent, true)!;
+      transformNode instanceof InstancedMesh
+        ? createMeshFromInstancedMesh(transformNode, newNodeName, clonedParent)
+        : transformNode.clone(newNodeName, clonedParent, true)!;
 
-    // bake transformation, so that we won't get negative values anymore
-    // also exchange material
+    // exchange material
     if (clonedNode instanceof Mesh) {
-      bakeGeometryOfMesh(clonedNode);
       const exchangeWithMaterial =
         clonedNode.material?.metadata?.[GltfExportManager._METADATA_PROPS.exchangeMaterialWith];
       if (exchangeWithMaterial) {
@@ -133,8 +141,8 @@ export class GltfExportManager {
       [GltfExportManager._METADATA_PROPS.deleteAfterExport]: true,
     });
 
-    // recourse into children
-    const childs = node.getChildTransformNodes(true);
+    // handle children
+    const childs = transformNode.getChildTransformNodes(true);
     childs.forEach(child => this._prepareNodeForExport(child, clonedNode, excluded));
   }
 
@@ -172,12 +180,12 @@ export class GltfExportManager {
   /**
    * Create an export-friendly replacement material for a material using refraction.
    */
-  protected _createRefractionMaterialReplacement(material: PBRMaterial): PBRMaterial {
+  protected _createRefractionMaterialReplacement(material: PBRMaterial) {
     const newName = `${material.name}_clone`;
-    // change material according to https://www.notion.so/combeenation/Glas-materials-don-t-look-glasy-after-export-d5fda2c6515e4420a8772744d3e6b460
-    const clonedMaterial = material.clone(newName); // clone material
+
+    const clonedMaterial = material.clone(newName);
     clonedMaterial.refractionTexture = null;
-    clonedMaterial.metallicReflectanceTexture = null; // is this the correct one for metallic roughness?
+    clonedMaterial.metallicReflectanceTexture = null;
     clonedMaterial.alpha = 0.7;
     clonedMaterial.albedoColor = new Color3(0.3, 0.3, 0.3);
     clonedMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_ALPHABLEND;
@@ -186,7 +194,5 @@ export class GltfExportManager {
 
     injectMetadata(material, { [GltfExportManager._METADATA_PROPS.exchangeMaterialWith]: newName });
     injectMetadata(clonedMaterial, { [GltfExportManager._METADATA_PROPS.deleteAfterExport]: true });
-
-    return clonedMaterial;
   }
 }

package/src/api/util/geometryHelper.ts

@@ -8,14 +8,24 @@ import type { MorphTarget } from '@babylonjs/core/Morph';
 import { MorphTargetManager } from '@babylonjs/core/Morph/morphTargetManager';
 import type { FloatArray } from '@babylonjs/core/types';
 
-const createMeshFromInstancedMesh = function (instancedMesh: InstancedMesh, newName: string) {
+const createMeshFromInstancedMesh = function (
+  instancedMesh: InstancedMesh,
+  newName: string,
+  clonedParent: Nullable<TransformNode>
+) {
   // first create a clone of the source mesh
-  const newMesh = instancedMesh.sourceMesh.clone(newName, instancedMesh.parent);
-  // apply the transformation data
-  newMesh.position = instancedMesh.position;
-  newMesh.rotation = instancedMesh.rotation;
-  newMesh.rotationQuaternion = instancedMesh.rotationQuaternion;
-  newMesh.scaling = instancedMesh.scaling;
+  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));