@combeenation/3d-viewer 15.1.0-beta1 → 16.0.0-alpha1

package/src/internal/cbn-custom-babylon-loader-plugin.ts

@@ -1,16 +1,54 @@
-import { AssetContainer, ISceneLoaderPlugin, InstancedMesh, SceneLoader } from '../index';
+import {
+  AssetContainer,
+  DecalConfiguration,
+  ISceneLoaderPlugin,
+  InstancedMesh,
+  SceneLoader,
+  ViewerError,
+  ViewerErrorIds,
+  createDecalMesh,
+} from '../index';
 import { setInternalMetadataValue } from './metadata-helper';
 import { deleteAllTags, getTags, setTagsAsString } from './tags-helper';
-import { isArray, isString } from 'lodash-es';
+import { isArray, isNumber, isString } from 'lodash-es';
+
+/**
+ * Contains cbn custom data, like decals.
+ * This is just a temporary type, as the `loadAssetContainer` function only returns an asset container, which can be
+ * altered by our file loader plugin.
+ * After loading the model, `cbnData` is cropped and a pure asset container is available for further processing.
+ */
+export class ExtendedAssetContainer extends AssetContainer {
+  cbnData?: CbnBabylonFileData;
+}
+
+export type CbnBabylonFileData = { decals?: ParsedDecalConfiguration[] };
+export type ParsedDecalConfiguration = DecalConfiguration & { materialId?: string };
+
+type DataWithMeshes = { meshes: unknown[] };
+type DataWithDecalConfigurations = { cbnData: { decals: unknown[] } };
+
+type MeshData = {
+  name: string;
+  materialId?: string;
+  instances?: unknown[];
+};
+
+type InstanceData = {
+  name: string;
+  tags?: string;
+};
 
 /**
  * Create and return a custom loader plugin to be registered with SceneLoader, that allows
  * us to run our own code against the input data before using the standard procedure to
  * import.
- * The main use case is to mark missing material in meshes, which will get loaded on demand at the first time the
- * dedicated mesh gets visible.
- * This is the case if the babylon file is a Combeenation "3d asset" which comes without materials, as the materials
- * are defined as "material assets".
+ * The main use cases are:
+ * - Marking missing material in meshes, which will get loaded on demand at the first time the dedicated mesh gets
+ *   visible. This is the case if the babylon file is a Combeenation "3d asset" which comes without materials, as the
+ *   materials are defined as "material assets".
+ * - Interpreting custom cbn data that have been injected in the babylon file, e.g. by the "decals editor" in the asset
+ *   editor area
  */
 export function registerCustomCbnBabylonLoaderPlugin(): void {
   // get original plugin for babylon files
@@ -23,46 +61,32 @@ export function registerCustomCbnBabylonLoaderPlugin(): void {
     extensions: '.babylon',
     importMesh: previousLoaderPlugin.importMesh,
     load: previousLoaderPlugin.load,
-    loadAssetContainer: function (scene, data, rootUrl, onError) {
-      // temporarily remove all morph target managers from scene before loading the model to avoid clashes with existing
-      // unique ids => see CB-9928
-      // NOTE: morph target managers still exist on the dedicated mesh when getting removed from the scene, only
-      // `scene.getMorphTargetManagerById` is affected, which is used internally in the `loadAssetContainer` function
-      const curMorphTargetManagers = scene.morphTargetManagers;
-      scene.morphTargetManagers = [];
-
+    loadAssetContainer: (scene, data, rootUrl, onError): ExtendedAssetContainer => {
       const dataParsed = JSON.parse(data as string);
       const importedContainer = previousLoaderPlugin.loadAssetContainer(scene, data, rootUrl);
 
       _addMissingMaterialMetadata(dataParsed, importedContainer);
       _reconstructTagsForInstancedMeshes(dataParsed, importedContainer);
+      _createDecals(dataParsed, importedContainer);
 
-      // restore existing morph target managers
-      scene.morphTargetManagers.push(...curMorphTargetManagers);
+      // add `cbnData` to output asset container, so that this information can be store as metadata for the model
+      const extendedContainer = importedContainer as ExtendedAssetContainer;
+      extendedContainer.cbnData = dataParsed.cbnData;
 
-      return importedContainer;
+      return extendedContainer;
     },
   };
 
   SceneLoader.RegisterPlugin(customLoader);
 }
 
-type InstanceData = {
-  name: string;
-  tags?: string;
-};
-
-function _isMeshInstanceData(data: any): data is InstanceData {
-  const hasName = isString(data.name);
-  const hasValidTags = !data.tags || isString(data.tags);
-  return hasName && hasValidTags;
+function _isDataWithMeshes(data: any): data is DataWithMeshes {
+  return isArray(data?.meshes);
 }
 
-type MeshData = {
-  name: string;
-  materialId?: string;
-  instances?: unknown[];
-};
+function _isDataWithDecalConfigurations(data: any): data is DataWithDecalConfigurations {
+  return isArray(data?.cbnData?.decals);
+}
 
 function _isMeshData(data: any): data is MeshData {
   const hasName = isString(data.name);
@@ -71,10 +95,31 @@ function _isMeshData(data: any): data is MeshData {
   return hasName && hasValidMaterialId;
 }
 
-type DataWithMeshes = { meshes: unknown[] };
+function _isMeshInstanceData(data: any): data is InstanceData {
+  const hasName = isString(data.name);
+  const hasValidTags = !data.tags || isString(data.tags);
 
-function _isDataWithMeshes(data: any): data is DataWithMeshes {
-  return data && isArray(data.meshes);
+  return hasName && hasValidTags;
+}
+
+function _isDecalConfiguration(data: any): data is ParsedDecalConfiguration {
+  const hasValidProps =
+    isString(data.name) &&
+    isString(data.sourceMeshName) &&
+    isArray(data.position) &&
+    isArray(data.normal) &&
+    isArray(data.size) &&
+    isNumber(data.angle) &&
+    isNumber(data.offset);
+
+  if (!hasValidProps) {
+    throw new ViewerError({
+      id: ViewerErrorIds.InvalidDecalConfiguration,
+      message: `Configuration for decal "${data.name}" invalid`,
+    });
+  }
+
+  return hasValidProps;
 }
 
 /**
@@ -138,3 +183,30 @@ function _reconstructTagsForInstancedMeshes(dataParsed: unknown, container: Asse
     }
   });
 }
+
+/**
+ * This function interprets the decal configuration, that is stored top level in the babylon file (`dataParsed`) and
+ * creates decal meshes in the given `container`.
+ *
+ * Having the decal information stored in that way is required for the "decals editor" in the asset manager, as meshes
+ * created from decals have to be updateable.
+ *
+ * @param container This is being manipulated, by adding decal meshes to it based on the decal configuration read from
+ *                  `dataParsed`.
+ */
+function _createDecals(dataParsed: unknown, container: AssetContainer): void {
+  if (!_isDataWithDecalConfigurations(dataParsed)) return;
+
+  const validatedDecals = dataParsed.cbnData.decals.filter(_isDecalConfiguration);
+
+  validatedDecals.forEach(decalConfig => {
+    const { materialId, ...decalMeshConfig } = decalConfig;
+    const decalMesh = createDecalMesh(decalMeshConfig, container, false);
+
+    // optionally set material directly
+    if (materialId) {
+      window.Cbn?.Assets.assertMaterialExists(materialId);
+      setInternalMetadataValue(decalMesh, 'deferredMaterial', materialId);
+    }
+  });
+}

package/src/internal/metadata-helper.ts

@@ -1,7 +1,7 @@
 import { BaseTexture, Material, Node } from '../index';
 import { cloneDeep } from 'lodash-es';
 
-type MetadataValue = string | number | boolean | undefined;
+type MetadataValue = string | number | boolean | object | undefined;
 type MetadataTarget = Node | Material | BaseTexture;
 type MetadataKeys =
   // CBN babylon loader

package/src/manager/model-manager.ts

@@ -1,6 +1,7 @@
 import {
   AssetContainer,
   BuiltInParameter,
+  DecalConfiguration,
   MaterialManager,
   MeshBuilder,
   ParameterManager,
@@ -10,6 +11,11 @@ import {
   ViewerError,
   ViewerErrorIds,
 } from '../index';
+import {
+  CbnBabylonFileData,
+  ExtendedAssetContainer,
+  ParsedDecalConfiguration,
+} from '../internal/cbn-custom-babylon-loader-plugin';
 import { cloneModelAssetContainer } from '../internal/cloning-helper';
 import { getInternalMetadataValue } from '../internal/metadata-helper';
 import { isArray } from 'lodash-es';
@@ -43,6 +49,7 @@ type Model = {
   url: string;
   state: ModelAssetState;
   assetContainer: AssetContainer;
+  cbnBabylonFileData?: CbnBabylonFileData;
   isClone: boolean;
   visibilityCallId?: number;
 };
@@ -359,6 +366,43 @@ export class ModelManager {
     return model.assetContainer;
   }
 
+  /**
+   * Returns the decals configuration of a certain model.\
+   * The model will be loaded before being able to access this configuration.\
+   * Decals are already converted to "normal" meshes when loading a model, still the original decals configuration can
+   * be useful e.g. for alterning decals.
+   */
+  public async getDecalsConfigurationOfModel(name: string): Promise<DecalConfiguration[]> {
+    const model = this._getModel(name);
+    if (!model) {
+      throw new ViewerError({
+        id: ViewerErrorIds.ModelNotRegistered,
+        message: `Can't get decals configuration of model "${name}" as model is not registered`,
+      });
+    }
+
+    if (model.state === 'notLoaded') {
+      await this._loadModel(model);
+    } else if (model.state === 'loading') {
+      await this._loadModelPromises[model.name];
+    }
+
+    if (model.state !== 'inScene') {
+      await this._prepareModelForScene(model);
+    }
+
+    // crop materialId as this is not part of `DecalConfiguration`
+    const decals = ((model.cbnBabylonFileData?.decals ?? []) as ParsedDecalConfiguration[]).map<DecalConfiguration>(
+      parsedDecal => {
+        const croppedDecal = parsedDecal;
+        delete croppedDecal.materialId;
+        return croppedDecal;
+      }
+    );
+
+    return decals;
+  }
+
   /**
    * Get model by name
    */
@@ -384,7 +428,18 @@ export class ModelManager {
 
       let assetContainer;
       try {
-        assetContainer = await SceneLoader.LoadAssetContainerAsync('', model.url, this.viewer.scene);
+        const fullContainer = (await SceneLoader.LoadAssetContainerAsync(
+          '',
+          model.url,
+          this.viewer.scene
+        )) as ExtendedAssetContainer;
+
+        // crop and store custom cbn data from .babylon file
+        model.cbnBabylonFileData = fullContainer.cbnData;
+        delete fullContainer.cbnData;
+
+        // from here it's a basic asset container again
+        assetContainer = fullContainer as AssetContainer;
       } catch (e) {
         throw new ViewerError({
           id: ViewerErrorIds.AssetLoadingFailed,

package/src/viewer-error.ts

@@ -29,6 +29,7 @@ export const ViewerErrorIds = {
   TextureCouldNotBeParsed: 'TextureCouldNotBeParsed',
   MaterialAlreadyExists: 'MaterialAlreadyExists',
   NotAClonedMaterial: 'NotAClonedMaterial',
+  InvalidDecalConfiguration: 'InvalidDecalConfiguration',
 };
 
 /** @internal */