@combeenation/3d-viewer 17.0.0 → 17.1.0

package/src/internal/texture-parameter-helper.ts

@@ -96,7 +96,7 @@ export function createBuiltInTextureParameter(parameterManager: ParameterManager
 
             if (!newTexture) {
               throw new ViewerError({
-                id: ViewerErrorIds.TextureCouldNotBeParsed,
+                id: ViewerErrorIds.InvalidParameterValue,
                 message: `Texture with url "${url}" could not be parsed`,
               });
             }
@@ -251,7 +251,10 @@ export function createBuiltInTextureParameter(parameterManager: ParameterManager
     for (const material of materials) {
       const materialCls = material.getClassName();
       if (materialCls !== 'PBRMaterial') {
-        throw new Error(`Enabling detailmap for material of instance "${materialCls}" not implemented`);
+        throw new ViewerError({
+          id: ViewerErrorIds.InvalidParameterSubject,
+          message: `Enabling detailmap for material of instance "${materialCls}" not implemented`,
+        });
       }
 
       const pbrMaterial = material as PBRMaterial;
@@ -270,7 +273,10 @@ export function createBuiltInTextureParameter(parameterManager: ParameterManager
 function _assertAndConvertPBRMaterial(material: Material, channel: string, parameter: string): PBRMaterial {
   const materialCls = material.getClassName();
   if (materialCls !== 'PBRMaterial') {
-    throw new Error(`Setting ${channel} ${parameter} for material of instance "${materialCls}" not implemented`);
+    throw new ViewerError({
+      id: ViewerErrorIds.InvalidParameterSubject,
+      message: `Setting ${channel} ${parameter} for material of instance "${materialCls}" not implemented`,
+    });
   }
 
   return material as PBRMaterial;

package/src/manager/camera-manager.ts

@@ -8,6 +8,8 @@ import {
   ScreenshotTools,
   Vector3,
   Viewer,
+  ViewerError,
+  ViewerErrorIds,
   ViewerEvent,
 } from '../index';
 import { isNodeExcluded } from '../internal/geometry-helper';
@@ -122,7 +124,10 @@ export class CameraManager {
     const activeCamera = this.viewer.scene.activeCamera;
 
     if (!(activeCamera instanceof ArcRotateCamera)) {
-      throw new Error(`Camera type "${activeCamera?.getClassName()}" is not implemented for "autofocusActiveCamera".`);
+      throw new ViewerError({
+        id: ViewerErrorIds.InvalidCameraType,
+        message: `"autofocusActiveCamera" function is not implemented for camera type "${activeCamera?.getClassName()}"`,
+      });
     }
 
     // get bounding box of all visible meshes, this is the base for the autofocus algorithm
@@ -176,7 +181,10 @@ export class CameraManager {
     const activeCamera = this.viewer.scene.activeCamera;
 
     if (!(activeCamera instanceof ArcRotateCamera)) {
-      throw new Error(`Camera type "${activeCamera?.getClassName()}" is not implemented yet for "moveActiveCameraTo".`);
+      throw new ViewerError({
+        id: ViewerErrorIds.InvalidCameraType,
+        message: `"moveActiveCameraTo" function is not implemented for camera type "${activeCamera?.getClassName()}"`,
+      });
     }
 
     if (durationMs === 0) {

package/src/manager/gltf-export-manager.ts

@@ -11,7 +11,6 @@ import {
   PBRMaterial,
   RenderTargetTexture,
   TransformNode,
-  Vector3,
   Viewer,
 } from '../index';
 import { getIsScaledDownDevice } from '../internal/device-helper';
@@ -28,8 +27,6 @@ import {
  * Manager for gltf export and augmented reality features
  */
 export class GltfExportManager {
-  protected static readonly _EXPORT_ROOT_NAME = '__export_root__';
-
   protected _maxTextureSize: number;
 
   /**
@@ -234,24 +231,11 @@ export class GltfExportManager {
         .forEach(material => GltfExportManager._exchangeMaterial(material as PBRMaterial));
     }
 
-    // since Babylon.js v6 the conversion to right handed GLB coordinate system is done differently
-    // previously the geometry itself has been altered, now they negate the scaling of all root nodes
-    // this is an issue for us, since we will receive this negated scalings in the exported GLB, which leads to issues
-    // on iOS devices
-    // we fix that by adding a top level root node with a negative scaling as well
-    // the exporter just removes this node as he detects a "noop root node" (implementation details of Babylon.js)
-    // everything beneath this node remains untouched
-    // TODO BJS Update: Test AR export on iPhones as well and double check if we still need this special logic
-    const exportRootNode = new TransformNode(GltfExportManager._EXPORT_ROOT_NAME, this.viewer.scene);
-    exportRootNode.scaling = new Vector3(-1, 1, 1);
-    setInternalMetadataValue(exportRootNode, 'exportNode', true);
-    setInternalMetadataValue(exportRootNode, 'deleteAfterExport', true);
-
     // create clones of each node (recursively), optionally exchange with cloned materials and mark these nodes for the
     // export
     this.viewer.scene.rootNodes
-      .filter(rootNode => rootNode.name !== GltfExportManager._EXPORT_ROOT_NAME)
-      .forEach(rootNode => this._prepareNodeForExport(rootNode, exportRootNode, excluded));
+      // .filter(rootNode => rootNode.name !== GltfExportManager._EXPORT_ROOT_NAME)
+      .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)
@@ -295,7 +279,11 @@ export class GltfExportManager {
    * Creates a clone of the node which should be used for the export.
    * Also switches to the cloned material if required.
    */
-  protected _prepareNodeForExport(node: Node, clonedParent: TransformNode, excluded?: ExcludedGeometryList): void {
+  protected _prepareNodeForExport(
+    node: Node,
+    clonedParent: TransformNode | null,
+    excluded?: ExcludedGeometryList
+  ): void {
     if (!GltfExportManager._shouldExportNode(node, excluded)) {
       return;
     }
@@ -338,14 +326,7 @@ export class GltfExportManager {
       nodes.push(...this.viewer.scene.transformNodes);
     }
 
-    const filteredNodes = nodes.filter(
-      node =>
-        getInternalMetadataValue(node, 'exportNode') &&
-        // in the desired use cases we want to exclude the export root node
-        // maybe add a parameter if we have to include it in certain scenarios in the future
-        node.name !== GltfExportManager._EXPORT_ROOT_NAME
-    );
-
+    const filteredNodes = nodes.filter(node => getInternalMetadataValue(node, 'exportNode'));
     return filteredNodes;
   }
 }

package/src/manager/model-manager.ts

@@ -426,12 +426,26 @@ export class ModelManager {
       const curEnvTexture = this.viewer.scene.environmentTexture;
       const curEnvIntensity = this.viewer.scene.environmentIntensity;
 
+      // CB-9240: Babylon.js doesn't recognize gzipped babylon files (`.babylon.gz`) as such, leading to a warning
+      // message, therefore we overwrite the plugin extension actively for such files
+      let pluginExtension;
+      try {
+        // URL constructor can throw for "valid" URL, which happened to be the case for the test asset environment where
+        // the urls are relative (starting with ".")
+        const urlObj = new URL(model.url);
+        if (urlObj.pathname.endsWith('.babylon.gz')) {
+          pluginExtension = '.babylon';
+        }
+      } catch (e) {}
+
       let assetContainer;
       try {
         const fullContainer = (await SceneLoader.LoadAssetContainerAsync(
           '',
           model.url,
-          this.viewer.scene
+          this.viewer.scene,
+          undefined,
+          pluginExtension
         )) as ExtendedAssetContainer;
 
         // crop and store custom cbn data from .babylon file

package/src/manager/parameter-manager.ts

@@ -5,6 +5,7 @@ import {
   Material,
   PBRMaterial,
   StandardMaterial,
+  Tags,
   TransformNode,
   Vector3,
   Viewer,
@@ -13,14 +14,14 @@ import {
 } from '../index';
 import { getInternalMetadataValue, setInternalMetadataValue } from '../internal/metadata-helper';
 import { paintableParameterObserver } from '../internal/paintable-helper';
-import { getTags, hasTag } from '../internal/tags-helper';
+import { getTagsAsStrArr } from '../internal/tags-helper';
 import {
   BuiltInTextureParameter,
   BuiltInTextureParameterKeys,
   ParameterTextureChannelsKeys,
   createBuiltInTextureParameter,
 } from '../internal/texture-parameter-helper';
-import { capitalize, isString } from 'lodash-es';
+import { capitalize, isNumber, isString } from 'lodash-es';
 
 /**
  * Parameters with a built in observer implementation
@@ -34,6 +35,7 @@ export const BuiltInParameter = {
   Color: 'color',
   Roughness: 'roughness',
   Metallic: 'metallic',
+  Influence: 'influence',
   /**
    * Texture parameters are always a combination of the channel (e.g. `albedoTexture`) and a sub parameter
    * (e.g. `uScale`). Use this function to create the parameter accordingly
@@ -49,8 +51,10 @@ export const LegacyParameter = {
   Paintable: 'paintable',
 };
 
+export type MorphTargetParameterValue = { name: string; value: number };
+
 export type ParameterName = string;
-export type ParameterValue = string | number | boolean;
+export type ParameterValue = string | number | boolean | Vector3 | Color3 | MorphTargetParameterValue;
 
 export type TagParameterSubject = { tagName: string; nodeName?: never; materialName?: never };
 export type NodeParameterSubject = { tagName?: never; nodeName: string; materialName?: never };
@@ -133,7 +137,16 @@ export class ParameterManager {
    * Parses and converts input to a number value
    */
   public static parseNumber(value: ParameterValue): number {
-    return parseFloat(value.toString());
+    const parsedNumber = parseFloat(value.toString());
+
+    if (isNaN(parsedNumber)) {
+      throw new ViewerError({
+        id: ViewerErrorIds.InvalidParameterValue,
+        message: `Unable to parse "${value}" to a number`,
+      });
+    }
+
+    return parsedNumber;
   }
 
   /**
@@ -143,11 +156,15 @@ export class ParameterManager {
     return value.toString();
   }
 
-  // TODO WTT: enable setting Vector3 on the input directly
   /**
-   * Parses a string of format "(x,y,z)"" to a "Vector3".
+   * Parses a string of format "(x,y,z)"" to a "Vector3".\
+   * Passing a Vector3 object directly is also valid.
    */
   public static parseVector(value: ParameterValue): Vector3 {
+    if (value instanceof Vector3) {
+      return value.clone();
+    }
+
     if (!isString(value)) {
       throw new ViewerError({
         id: ViewerErrorIds.InvalidParameterValue,
@@ -167,26 +184,35 @@ export class ParameterManager {
     }
   }
 
-  // TODO WTT: enable setting Vector3 on the input directly (maybe quaternion as well)
   /**
-   * Parses a string of format `'(x,y,z)'` with angular degrees to a `Vector3` with rotation information in radians.
+   * Parses a string of format `'(x,y,z)'` with angular degrees to a `Vector3` with rotation information in radians.\
+   * Passing a Vector3 object directly is also valid, in this case no degrees to radians conversion is made.
    */
   public static parseRotation(value: ParameterValue): Vector3 {
     const rotation = ParameterManager.parseVector(value);
-    const deg2rad = (deg: number): number => {
-      return (deg * Math.PI) / 180;
-    };
-    return rotation.set(deg2rad(rotation.x), deg2rad(rotation.y), deg2rad(rotation.z));
+
+    if (isString(value)) {
+      const deg2rad = (deg: number): number => {
+        return (deg * Math.PI) / 180;
+      };
+      return rotation.set(deg2rad(rotation.x), deg2rad(rotation.y), deg2rad(rotation.z));
+    } else {
+      return rotation;
+    }
   }
 
-  // TODO WTT: enable setting Color3 on the input directly
   /**
-   * Parses a string of format `'#rrggbb'` or `'(r,g,b)'` to a `Color3`.
+   * Parses a string of format `'#rrggbb'` or `'(r,g,b)'` to a `Color3`.\
+   * Passing a Color3 object directly is also valid.
    */
   public static parseColor(value: ParameterValue): Color3 {
+    if (value instanceof Color3) {
+      return value.clone();
+    }
+
     const cleanedValue = value.toString().split(' ').join('');
     if (cleanedValue.startsWith('#')) {
-      return Color3.FromHexString(value.toString());
+      return Color3.FromHexString(cleanedValue);
     }
     if (cleanedValue.startsWith('(') && cleanedValue.endsWith(')')) {
       const rgb = cleanedValue.substring(1, cleanedValue.length - 1);
@@ -204,6 +230,31 @@ export class ParameterManager {
     });
   }
 
+  public static parseMorphTarget(value: ParameterValue): MorphTargetParameterValue {
+    let objValue;
+    if (isString(value)) {
+      try {
+        objValue = JSON.parse(value);
+      } catch {
+        throw new ViewerError({
+          id: ViewerErrorIds.InvalidParameterValue,
+          message: `Unable to parse "${value}" to a morph target parameter value: not a parseable string`,
+        });
+      }
+    } else {
+      objValue = value;
+    }
+
+    if (isString(objValue.name) && isNumber(objValue.value)) {
+      return { name: objValue.name, value: objValue.value };
+    } else {
+      throw new ViewerError({
+        id: ViewerErrorIds.InvalidParameterValue,
+        message: `Unable to parse "${value}" to a morph target parameter value: wrong format`,
+      });
+    }
+  }
+
   protected _parameterEntries: ParameterEntry[] = [];
   protected _parameterObserver: { [parameterName: ParameterName]: ParameterObserver } = {};
 
@@ -352,7 +403,7 @@ export class ParameterManager {
    * @internal
    */
   public async applyParameterValuesToMaterial(material: Material): Promise<void> {
-    const tags = getTags(material);
+    const tags = getTagsAsStrArr(material);
 
     const parameterEntriesToApply: ParameterEntry[] = [];
     tags.forEach(tagName => {
@@ -383,7 +434,7 @@ export class ParameterManager {
     material: PBRMaterial,
     channel: ParameterTextureChannelsKeys
   ): Promise<void> {
-    const tags = getTags(material);
+    const tags = getTagsAsStrArr(material);
 
     const parameterEntriesToApply: ParameterEntry[] = [];
     tags.forEach(tagName => {
@@ -419,7 +470,7 @@ export class ParameterManager {
       return nodeParamValue;
     }
 
-    const tags = getTags(node);
+    const tags = getTagsAsStrArr(node);
     const tagParamValue = tags.reduce<ParameterValue | undefined>((accValue, curTag) => {
       // NOTE: it is possible that values are available for multiple tags
       // in this case the resulting parameter value is quite "random" as the last tag in the tag string of the node has
@@ -444,7 +495,7 @@ export class ParameterManager {
       return materialParamValue;
     }
 
-    const tags = getTags(material);
+    const tags = getTagsAsStrArr(material);
     const tagParamValue = tags.reduce<ParameterValue | undefined>((accValue, curTag) => {
       const tagParamValue = this.getParameterValue({ tagName: curTag }, parameterName);
       return accValue ?? tagParamValue;
@@ -487,6 +538,13 @@ export class ParameterManager {
       const material = ParameterManager.parseString(newValue);
 
       for (const node of nodes) {
+        if (!(node instanceof AbstractMesh)) {
+          throw new ViewerError({
+            id: ViewerErrorIds.InvalidParameterSubject,
+            message: `Material can't be set, as the target node "${node.name}" is not a mesh`,
+          });
+        }
+
         // NOTE: don't use node.isEnabled() as visibility observer is probably called in same cycle but later
         // however the parameter value is already correct at this stage
         // we have to go through all parents as well, because a parent may have been set to false, which also disables
@@ -501,14 +559,10 @@ export class ParameterManager {
           curNode = curNode.parent as TransformNode;
         }
 
-        // parameter visibility has priority, but if the visiblity is not controlled by the parameter use the plain
-        // Babylon.js isEnabled() check
         const visible =
           visibleByParameter !== undefined ? ParameterManager.parseBoolean(visibleByParameter) : node.isEnabled();
         if (visible) {
-          // TODO WTT: check mesh type and throw error if it doesn't fit
-          // think of creating a framework with type guards (isMesh, canHaveMaterial, ...) around this
-          await this.viewer.materialManager.setMaterialOnMesh(material, node as AbstractMesh);
+          await this.viewer.materialManager.setMaterialOnMesh(material, node);
         } else {
           setInternalMetadataValue(node, 'deferredMaterial', material);
         }
@@ -548,7 +602,10 @@ export class ParameterManager {
             (material as StandardMaterial).diffuseColor = color;
             break;
           default:
-            throw new Error(`Setting color for material of instance "${materialCls}" not implemented`);
+            throw new ViewerError({
+              id: ViewerErrorIds.InvalidParameterSubject,
+              message: `Setting color for material of instance "${materialCls}" not implemented`,
+            });
         }
       }
     });
@@ -565,7 +622,10 @@ export class ParameterManager {
             (material as StandardMaterial).roughness = roughness;
             break;
           default:
-            throw new Error(`Setting rougness for material of instance "${materialCls}" not implemented`);
+            throw new ViewerError({
+              id: ViewerErrorIds.InvalidParameterSubject,
+              message: `Setting rougness for material of instance "${materialCls}" not implemented`,
+            });
         }
       }
     });
@@ -579,7 +639,26 @@ export class ParameterManager {
             (material as PBRMaterial).metallic = metallic;
             break;
           default:
-            throw new Error(`Setting metallic for material of instance "${materialCls}" not implemented`);
+            throw new ViewerError({
+              id: ViewerErrorIds.InvalidParameterSubject,
+              message: `Setting metallic for material of instance "${materialCls}" not implemented`,
+            });
+        }
+      }
+    });
+    this.setParameterObserver(BuiltInParameter.Influence, async ({ nodes, newValue }) => {
+      const morphTargetValue = ParameterManager.parseMorphTarget(newValue);
+
+      for (const node of nodes) {
+        const target = node instanceof AbstractMesh && node.morphTargetManager?.getTargetByName(morphTargetValue.name);
+
+        if (target) {
+          target.influence = morphTargetValue.value;
+        } else {
+          throw new ViewerError({
+            id: ViewerErrorIds.InvalidParameterSubject,
+            message: `Morph target couldn't be found, node: ${node.name} / morph target: ${morphTargetValue.name}`,
+          });
         }
       }
     });
@@ -679,7 +758,7 @@ export class ParameterManager {
         console.warn(`Multiple materials for material name "${subject.materialName}" have been found`);
       }
     } else if (isTagParameterSubject(subject)) {
-      materials = assetContainer.materials.filter(material => hasTag(material, subject.tagName));
+      materials = assetContainer.materials.filter(material => Tags.MatchesQuery(material, subject.tagName));
     }
 
     return materials;
@@ -697,7 +776,7 @@ export class ParameterManager {
         console.warn(`Multiple nodes for node name "${subject.nodeName}" have been found`);
       }
     } else if (isTagParameterSubject(subject)) {
-      nodes = allNodes.filter(node => hasTag(node, subject.tagName));
+      nodes = allNodes.filter(node => Tags.MatchesQuery(node, subject.tagName));
     }
 
     return nodes;

package/src/viewer-error.ts

@@ -21,14 +21,15 @@ type ViewerErrorData = {
  */
 export const ViewerErrorIds = {
   InvalidParameterValue: 'InvalidParameterValue',
+  InvalidParameterSubject: 'InvalidParameterSubject',
   ModelNotRegistered: 'ModelNotRegistered',
   ModelAlreadyExists: 'ModelAlreadyExists',
   ModelIsNotAClone: 'ModelIsNotAClone',
   AssetLoadingFailed: 'AssetLoadingFailed',
-  TextureCouldNotBeParsed: 'TextureCouldNotBeParsed',
   MaterialAlreadyExists: 'MaterialAlreadyExists',
   NotAClonedMaterial: 'NotAClonedMaterial',
   InvalidDecalConfiguration: 'InvalidDecalConfiguration',
+  InvalidCameraType: 'InvalidCameraType',
 };
 
 /** @internal */