@combeenation/3d-viewer 14.1.0 → 15.1.0-beta1

package/src/manager/parameter-manager.ts

@@ -1,7 +1,7 @@
 import {
   AbstractMesh,
-  AbstractScene,
   Color3,
+  IAssetContainer,
   Material,
   PBRMaterial,
   StandardMaterial,
@@ -14,6 +14,12 @@ import {
 import { getInternalMetadataValue, setInternalMetadataValue } from '../internal/metadata-helper';
 import { paintableParameterObserver } from '../internal/paintable-helper';
 import { getTags, hasTag } from '../internal/tags-helper';
+import {
+  BuiltInTextureParameter,
+  BuiltInTextureParameterKeys,
+  ParameterTextureChannelsKeys,
+  createBuiltInTextureParameter,
+} from '../internal/texture-parameter-helper';
 import { capitalize, isString } from 'lodash-es';
 
 /**
@@ -28,6 +34,18 @@ export const BuiltInParameter = {
   Color: 'color',
   Roughness: 'roughness',
   Metallic: 'metallic',
+  /**
+   * 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
+   * (e.g. createTextureParameter("albedoTexture", "uScale")).
+   */
+  createTextureParameter: (channel: ParameterTextureChannelsKeys, parameter: BuiltInTextureParameterKeys): string =>
+    `${channel}.${parameter}`,
+  UseDetailmap: 'useDetailmap',
+};
+
+/** @ignore @deprected Use "texture parameters" {@link BuiltInParameter}.`createTextureParameter` instead */
+export const LegacyParameter = {
   Paintable: 'paintable',
 };
 
@@ -319,19 +337,31 @@ export class ParameterManager {
 
   /**
    * Applies all existing parameter entries to a certain "model", as defined in the {@link ModelManager}.\
-   * This can be usefull when updating the model before showing it in the scene.
+   * This can be useful when updating the model before showing it in the scene.
+   *
+   * @internal
+   */
+  public async applyAllParameterValuesToModel(model: IAssetContainer): Promise<void> {
+    await this._applyParameterValues(this._parameterEntries, model);
+  }
+
+  /**
+   * Removes existing parameter entries of all nodes of a model.\
+   * This can be useful to clean up the parameter state when removing a (cloned) model.
    *
    * @internal
    */
-  public async applyAllParameterValuesToModel(model: AbstractScene): Promise<void> {
-    const parameterEntriesToApply = this._parameterEntries;
+  public removeParameterEntriesOfModel(model: IAssetContainer): void {
+    const allNodeNames = [...model.meshes, ...model.transformNodes].map(node => node.name);
 
-    await this._applyParameterValues(parameterEntriesToApply, model);
+    this._parameterEntries = this._parameterEntries.filter(
+      entry => !allNodeNames.includes(entry.subject.nodeName ?? '')
+    );
   }
 
   /**
    * Applies all parameter values which are targeting a material.\
-   * This can be usefull when updating a material definition before creating it.
+   * This can be useful when updating a material definition before creating it.
    *
    * @internal
    */
@@ -350,6 +380,50 @@ export class ParameterManager {
     await this._applyParameterValues(parameterEntriesToApply);
   }
 
+  /**
+   * Removes all parameter entries of a certain material.\
+   * This can be useful to clean up the parameter state when removing a (cloned) material.
+   *
+   * @internal
+   */
+  public removeParameterEntriesOfMaterial(material: Material): void {
+    this._parameterEntries = this._parameterEntries.filter(entry => entry.subject.materialName !== material.id);
+  }
+
+  /**
+   * Applies subset of texture parameter values which are targeting a certain texture channel in a material.\
+   * This can be useful when updating texture settings (e.g. uScale) before the texture is actually created.
+   *
+   * @internal
+   */
+  public async applyTextureSettingsParameter(
+    material: PBRMaterial,
+    channel: ParameterTextureChannelsKeys
+  ): Promise<void> {
+    const tags = getTags(material);
+
+    const parameterEntriesToApply: ParameterEntry[] = [];
+    tags.forEach(tagName => {
+      const tagParamEntries = this._getEntriesOfSubject({ tagName });
+      parameterEntriesToApply.push(...tagParamEntries);
+    });
+
+    const materialParamEntries = this._getEntriesOfSubject({ materialName: material.id });
+    parameterEntriesToApply.push(...materialParamEntries);
+
+    const textureParameterEntriesToApply = parameterEntriesToApply.filter(parameterEntry => {
+      const paramPath = parameterEntry.parameterName.split('.');
+      // find texture parameters of this channel, e.g. "albedoTexture.uScale"
+      // "image" should not be applied here as this is part of the texture initialization anyway
+      const isTextureParamOfChannel =
+        paramPath.length === 2 && paramPath[0] === channel && paramPath[1] !== BuiltInTextureParameter.image;
+
+      return isTextureParamOfChannel;
+    });
+
+    await this._applyParameterValues(textureParameterEntriesToApply);
+  }
+
   /**
    * @returns Desired parameter value of a certain node.
    * Tags are considered as well but have lower priority than node parameters, as these are more specific.
@@ -405,9 +479,19 @@ export class ParameterManager {
 
       for (const node of nodes) {
         if (visible) {
-          const deferredMaterial = getInternalMetadataValue(node, 'deferredMaterial');
-          if (deferredMaterial) {
-            await this.viewer.materialManager.setMaterialOnMesh(deferredMaterial as string, node as AbstractMesh);
+          // if a mesh gets visible by this operation we have to activate the assigned material which is stored in the
+          // internal metadata
+          // => consider child meshes as well (CB-10143)
+          const activatedNodes = [node, ...node.getChildMeshes(false)];
+          for (const activatedNode of activatedNodes) {
+            const deferredMaterial = getInternalMetadataValue(activatedNode, 'deferredMaterial');
+            if (deferredMaterial) {
+              await this.viewer.materialManager.setMaterialOnMesh(
+                deferredMaterial as string,
+                // this cast is fine, as deferred material can only be set on meshes
+                activatedNode as AbstractMesh
+              );
+            }
           }
 
           node.setEnabled(true);
@@ -422,9 +506,22 @@ export class ParameterManager {
       for (const node of nodes) {
         // 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
-        const rawVisibleValue = this.getParameterValueOfNode(node, BuiltInParameter.Visible);
+        // we have to go through all parents as well, because a parent may have been set to false, which also disables
+        // this child node
+        let curNode: TransformNode | null = node;
+        let visibleByParameter: boolean | undefined = undefined;
+        while (curNode && visibleByParameter !== false) {
+          const curNodeVisibleByParameter = this.getParameterValueOfNode(curNode, BuiltInParameter.Visible);
+          if (curNodeVisibleByParameter !== undefined) {
+            visibleByParameter = curNodeVisibleByParameter as boolean;
+          }
+          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 =
-          rawVisibleValue !== undefined ? ParameterManager.parseBoolean(rawVisibleValue) : node.isEnabled();
+          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
@@ -503,9 +600,12 @@ export class ParameterManager {
         }
       }
     });
-    this.setParameterObserver(BuiltInParameter.Paintable, async ({ newValue, materials }) => {
+    this.setParameterObserver(LegacyParameter.Paintable, async ({ newValue, materials }) => {
       paintableParameterObserver(newValue, materials, this.viewer.scene);
     });
+
+    // texture parameter use a more generic approach (`channel`.`parameter`) and are therefore coded in a dedicated file
+    createBuiltInTextureParameter(this, this.viewer.scene);
   }
 
   /**
@@ -543,7 +643,7 @@ export class ParameterManager {
    */
   protected async _applyParameterValues(
     parameterEntries: ParameterEntry[],
-    assetContainer?: AbstractScene
+    assetContainer?: IAssetContainer
   ): Promise<void> {
     const tagParamEntries = parameterEntries.filter(entry => isTagParameterSubject(entry.subject));
     const nonTagParamEntries = parameterEntries.filter(entry => !isTagParameterSubject(entry.subject));
@@ -565,7 +665,7 @@ export class ParameterManager {
   protected async _applyParameterValue(
     subject: ParameterSubject,
     parameterName: ParameterName,
-    assetContainer?: AbstractScene
+    assetContainer?: IAssetContainer
   ): Promise<void> {
     const parameterEntry = this._getEntry(subject, parameterName);
     const observer = this._parameterObserver[parameterName];
@@ -585,7 +685,7 @@ export class ParameterManager {
     });
   }
 
-  protected _getAffectedMaterials(subject: ParameterSubject, assetContainer?: AbstractScene): Material[] {
+  protected _getAffectedMaterials(subject: ParameterSubject, assetContainer?: IAssetContainer): Material[] {
     assetContainer = assetContainer ?? this.viewer.scene;
     let materials: Material[] = [];
 
@@ -602,7 +702,7 @@ export class ParameterManager {
     return materials;
   }
 
-  protected _getAffectedNodes(subject: ParameterSubject, assetContainer?: AbstractScene): TransformNode[] {
+  protected _getAffectedNodes(subject: ParameterSubject, assetContainer?: IAssetContainer): TransformNode[] {
     assetContainer = assetContainer ?? this.viewer.scene;
     const allNodes = [...assetContainer.meshes, ...assetContainer.transformNodes];
     let nodes: TransformNode[] = [];

package/src/viewer-error.ts

@@ -26,6 +26,9 @@ export const ViewerErrorIds = {
   ModelIsNotAClone: 'ModelIsNotAClone',
   AssetLoadingFailed: 'AssetLoadingFailed',
   MaterialCouldNotBeParsed: 'MaterialCouldNotBeParsed',
+  TextureCouldNotBeParsed: 'TextureCouldNotBeParsed',
+  MaterialAlreadyExists: 'MaterialAlreadyExists',
+  NotAClonedMaterial: 'NotAClonedMaterial',
 };
 
 /** @internal */

package/src/viewer.ts

@@ -112,7 +112,7 @@ export class Viewer {
     return this._scene;
   }
   get engine(): Engine {
-    return this.scene.getEngine();
+    return this.scene.getEngine() as Engine;
   }
   get cameraManager(): CameraManager {
     return this._cameraManager;