@combeenation/3d-viewer 18.1.0 → 18.2.0

package/src/internal/node-helper.ts

@@ -0,0 +1,73 @@
+import { AbstractMesh, DimensionLineManager, HtmlAnchorManager, ParameterSubject, Tags, TransformNode } from '..';
+
+type NodeCheckCriteria = {
+  isInList?: (TransformNode | ParameterSubject)[];
+  isDisabled?: boolean;
+  hasInvalidBoundingInfo?: boolean;
+  hasInfiniteDistance?: boolean;
+  isGeneratedBackgroundMesh?: boolean;
+  isHtmlAnchorMesh?: boolean;
+  isDimensionLine?: boolean;
+};
+
+const _DEFAULT_BACKGROUND_PARENT_NAME = 'BackgroundHelper';
+
+/**
+ * Checks if transform node matches any of the given criterias.
+ */
+export function nodeMatchesAnyCriteria(nodeToCheck: TransformNode, criteria: NodeCheckCriteria): boolean {
+  const {
+    isInList,
+    isDisabled,
+    hasInvalidBoundingInfo,
+    hasInfiniteDistance,
+    isGeneratedBackgroundMesh,
+    isHtmlAnchorMesh,
+    isDimensionLine,
+  } = criteria ?? {};
+
+  const matchesIsInList = (isInList ?? []).some(geometryToExclude => {
+    if (geometryToExclude instanceof TransformNode) {
+      // CAUTION: node has to be the same instance
+      return geometryToExclude === nodeToCheck;
+    }
+    if (geometryToExclude.tagName || geometryToExclude.nodeName) {
+      const nameMatches = !!geometryToExclude.nodeName && geometryToExclude.nodeName === nodeToCheck.name;
+      const tagMatches = !!geometryToExclude.tagName && Tags.MatchesQuery(nodeToCheck, geometryToExclude.tagName);
+      return nameMatches || tagMatches;
+    }
+    return false;
+  });
+
+  const isMesh = nodeToCheck instanceof AbstractMesh;
+  const matchesIsDisabled = !!isDisabled && !nodeToCheck.isEnabled(false);
+  const matchesHasInvalidBoundingInfo =
+    !!hasInvalidBoundingInfo && isMesh && nodeToCheck.getBoundingInfo().boundingSphere.radius === 0;
+  const matchesHasInfiniteDistance = !!hasInfiniteDistance && nodeToCheck.infiniteDistance;
+  // this targets generated ground and skybox meshes from `scene.createDefaultEnvironment`, as they are located
+  // underneath `BackgroundHelper`
+  const matchesIsGeneratedBackgroundMesh =
+    !!isGeneratedBackgroundMesh && nodeToCheck.name === _DEFAULT_BACKGROUND_PARENT_NAME;
+  const matchesIsHtmlAnchorMesh = !!isHtmlAnchorMesh && HtmlAnchorManager.isHtmlAnchorMesh(nodeToCheck);
+  const matchesIsDimensionLine = !!isDimensionLine && DimensionLineManager.isDimensionLineMesh(nodeToCheck);
+
+  let matchesAnyCriteria =
+    matchesIsInList ||
+    matchesIsDisabled ||
+    matchesHasInvalidBoundingInfo ||
+    matchesHasInfiniteDistance ||
+    matchesIsGeneratedBackgroundMesh ||
+    matchesIsHtmlAnchorMesh ||
+    matchesIsDimensionLine;
+  // consider parent as well, BUT ONLY for list and disabled state, as the other criterias have nothing to do with a
+  // child-parent relation
+  if (!matchesAnyCriteria && nodeToCheck.parent instanceof TransformNode) {
+    matchesAnyCriteria = nodeMatchesAnyCriteria(nodeToCheck.parent, {
+      isInList,
+      isDisabled,
+      isGeneratedBackgroundMesh,
+    });
+  }
+
+  return matchesAnyCriteria;
+}

package/src/manager/camera-manager.ts

@@ -3,7 +3,7 @@ import {
   AnimationGroup,
   ArcRotateCamera,
   BoundingSphere,
-  ExcludedGeometryList,
+  NodeDescription,
   ScreenshotTools,
   Vector3,
   Viewer,
@@ -11,7 +11,7 @@ import {
   ViewerErrorIds,
   ViewerEvent,
 } from '../index';
-import { isNodeExcluded } from '../internal/geometry-helper';
+import { nodeMatchesAnyCriteria } from '../internal/node-helper';
 import { createScreenshotCanvas, trimCanvas } from '../internal/screenshot-helper';
 
 export type CameraPosition = {
@@ -31,8 +31,8 @@ export type AutofocusSettings = {
   alpha?: number;
   /** Desired vertical camera angle, this won't be overwritten by the autofocus function */
   beta?: number;
-  /** Optional list of geometry to be excluded from consideration */
-  exclude?: ExcludedGeometryList;
+  /** Optional list of nodes to be excluded from camera distance calculation for autofocusing */
+  excludeNodes?: NodeDescription[];
   durationMs?: number;
 };
 
@@ -62,8 +62,8 @@ export type ScreenshotSettings = {
   /** Can be used to automatically calculate camera `radius` and `target`, if these 2 settings are not defined
    * explicitely */
   autofocusScene?: boolean;
-  /** Optional list of geometry to be excluded from consideration */
-  exclude?: ExcludedGeometryList;
+  /** Optional list of nodes to be excluded from screenshot */
+  excludeNodes?: NodeDescription[];
   /**
    * Optional list of html anchor groups (see {@link HtmlAnchorManager}), that should be excluded from the screenshot.\
    * Excludes ALL html anchor groups if set to `true`.
@@ -160,7 +160,7 @@ export class CameraManager {
     }
 
     // get bounding box of all visible meshes, this is the base for the autofocus algorithm
-    const boundingInfo = this.viewer.sceneManager.calculateBoundingInfo(settings?.exclude);
+    const boundingInfo = this.viewer.sceneManager.calculateBoundingInfo(settings?.excludeNodes);
     // optionally show bounding sphere for debugging purpose
     this.viewer.eventManager.fireEvent(ViewerEvent.AutofocusStart, boundingInfo.boundingSphere);
 
@@ -306,7 +306,7 @@ export class CameraManager {
       radius,
       target,
       autofocusScene,
-      exclude,
+      excludeNodes,
       excludeHtmlAnchorGroups,
       cropTransparentArea,
       fileName,
@@ -321,7 +321,7 @@ export class CameraManager {
     const screenshotCam = this.viewer.scene.activeCamera?.clone(
       CameraManager._SCREENSHOT_CAMERA_NAME
     ) as ArcRotateCamera;
-    const boundingInfo = autofocusScene ? this.viewer.sceneManager.calculateBoundingInfo(exclude) : undefined;
+    const boundingInfo = autofocusScene ? this.viewer.sceneManager.calculateBoundingInfo(excludeNodes) : undefined;
 
     if (alpha !== undefined) {
       screenshotCam.alpha = alpha;
@@ -363,10 +363,8 @@ export class CameraManager {
       useLayerMask,
       quality,
       texture => {
-        // NOTE: this doesn't work ATM, see https://github.com/BabylonJS/Babylon.js/pull/16081#issuecomment-2652861176
-        // we'll have to wait for a fix or solve the visibility in a different way (e.g. camera layer mask)
         texture.renderList = this.viewer.scene.meshes.filter(
-          mesh => !settings?.exclude || !isNodeExcluded(mesh, settings.exclude)
+          mesh => !nodeMatchesAnyCriteria(mesh, { isInList: excludeNodes })
         );
       }
     );

package/src/manager/dimension-line-manager.ts

@@ -82,6 +82,15 @@ export class DimensionLineManager {
     };
   } = {};
 
+  /**
+   * Check if input node is a dimension line mesh, created by this manager.\
+   * Dimension lines have a dedicated tag set, which is checked here.
+   * @internal
+   */
+  public static isDimensionLineMesh(node: TransformNode): boolean {
+    return Tags.MatchesQuery(node, DimensionLineManager.DIMENSION_LINE_KEY);
+  }
+
   /** @internal */
   public constructor(protected viewer: Viewer) {}
 

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

@@ -1,13 +1,13 @@
 import {
   Animation,
   DynamicTexture,
-  ExcludedGeometryList,
   GLTF2Export,
   IExportOptions,
   InstancedMesh,
   Material,
   Mesh,
   Node,
+  NodeDescription,
   PBRMaterial,
   RenderTargetTexture,
   TransformNode,
@@ -15,13 +15,13 @@ import {
 } from '../index';
 import { getIsScaledDownDevice } from '../internal/device-helper';
 import { bakeGeometryOfMesh, createMeshFromInstancedMesh, resetTransformation } from '../internal/geometry-helper';
-import { isNodeExcluded } from '../internal/geometry-helper';
 import {
   clearInternalMetadataValue,
   cloneInternalMetadata,
   getInternalMetadataValue,
   setInternalMetadataValue,
 } from '../internal/metadata-helper';
+import { nodeMatchesAnyCriteria } from '../internal/node-helper';
 
 /**
  * Manager for gltf export and augmented reality features
@@ -35,15 +35,15 @@ export class GltfExportManager {
    * stay `true` in order to make the AR export work.
    * We could theoretically allow it if AR optimization is not desired, but this may confuse the user.
    */
-  protected static _gltfExportOptions(optimizeForAR: boolean, excluded?: ExcludedGeometryList): IExportOptions {
+  protected static _gltfExportOptions(optimizeForAR: boolean, excludeNodes?: NodeDescription[]): IExportOptions {
     return {
       shouldExportNode: function (node: Node): boolean {
         if (optimizeForAR) {
           // we explicitely marked nodes, that should be exported in AR mode
-          return getInternalMetadataValue(node, 'exportNode');
+          return !!getInternalMetadataValue(node, 'exportNode');
         } else {
           // use the default export node check (enabled state, exclusion list, etc...)
-          return GltfExportManager._shouldExportNode(node, excluded);
+          return GltfExportManager._shouldExportNode(node, excludeNodes);
         }
       },
 
@@ -54,19 +54,19 @@ export class GltfExportManager {
   /**
    * Checks if a node should be available in the export
    */
-  protected static _shouldExportNode(node: Node, excluded?: ExcludedGeometryList): boolean {
+  protected static _shouldExportNode(node: Node, excludeNodes?: NodeDescription[]): boolean {
     if (!(node instanceof TransformNode)) {
       return false;
     }
-    // TODO WTT: think of adding "BackgroundHelper" and nodes with "infiniteDistance" here as well, at least in AR mode
-    if (!node.isEnabled()) {
-      return false;
-    }
-    if (excluded && isNodeExcluded(node, excluded)) {
-      return false;
-    }
 
-    return true;
+    // maybe add some other criterias like "hasInfiniteDistance" and "isGeneratedBackgroundMesh" here as well
+    const isExcluded = nodeMatchesAnyCriteria(node, {
+      isInList: excludeNodes,
+      isDisabled: true,
+      isHtmlAnchorMesh: true,
+    });
+
+    return !isExcluded;
   }
 
   /**
@@ -120,19 +120,19 @@ export class GltfExportManager {
    * @param filename Optional name of the exported .GLB file.
    * @param optimizeForAR Adjusts the exported GLB so that known issues get automatically fixed, this
    *                      is mostly targeting Apples .usdz format.
-   * @param excluded Optional list of geometry (meshes, elements, variants,...) to be excluded from the export.
+   * @param excludeNodes Optional list of nodes to be excluded from the export.
    */
   public async exportGlb(
     filename = 'glb-export.glb',
     optimizeForAR: boolean = false,
-    excluded?: ExcludedGeometryList
+    excludeNodes?: NodeDescription[]
   ): Promise<File | undefined> {
-    await this._exportPreProcess(optimizeForAR, excluded);
+    await this._exportPreProcess(optimizeForAR, excludeNodes);
 
     const glbData = await GLTF2Export.GLBAsync(
       this.viewer.scene,
       'dummy',
-      GltfExportManager._gltfExportOptions(optimizeForAR, excluded)
+      GltfExportManager._gltfExportOptions(optimizeForAR, excludeNodes)
     );
 
     await this._exportPostProcess(optimizeForAR);
@@ -155,19 +155,19 @@ export class GltfExportManager {
    * @param filename Name of the main (text-based) .GLTF file referring to separate texture files.
    * @param optimizeForAR Adjusts the exported GLB so that known issues get automatically fixed, this
    *                      is mostly targeting Apples .usdz format.
-   * @param excluded Optional list of geometry (meshes, elements, variants,...) to be excluded from the export.
+   * @param excludeNodes Optional list of nodes to be excluded from the export.
    */
   public async exportGltfToFile(
     filename: string,
     optimizeForAR: boolean = false,
-    excluded?: ExcludedGeometryList
+    excludeNodes?: NodeDescription[]
   ): Promise<void> {
-    await this._exportPreProcess(optimizeForAR, excluded);
+    await this._exportPreProcess(optimizeForAR, excludeNodes);
 
     const gltf = await GLTF2Export.GLTFAsync(
       this.viewer.scene,
       filename,
-      GltfExportManager._gltfExportOptions(optimizeForAR, excluded)
+      GltfExportManager._gltfExportOptions(optimizeForAR, excludeNodes)
     );
     gltf.downloadFiles();
 
@@ -179,19 +179,19 @@ export class GltfExportManager {
    * @param filename Name of the main (text-based) .GLTF file referring to seperate texture files.
    * @param optimizeForAR Adjusts the exported GLB so that known issues get automatically fixed, this
    *                      is mostly targeting Apples .usdz format.
-   * @param excluded Optional list of geometry (meshes, elements, variants,...) to be excluded from the export.
+   * @param excludeNodes Optional list of nodes to be excluded from the export.
    */
   public async exportGlbToFile(
     filename: string,
     optimizeForAR: boolean = false,
-    excluded?: ExcludedGeometryList
+    excludeNodes?: NodeDescription[]
   ): Promise<void> {
-    await this._exportPreProcess(optimizeForAR, excluded);
+    await this._exportPreProcess(optimizeForAR, excludeNodes);
 
     const glb = await GLTF2Export.GLBAsync(
       this.viewer.scene,
       filename,
-      GltfExportManager._gltfExportOptions(optimizeForAR, excluded)
+      GltfExportManager._gltfExportOptions(optimizeForAR, excludeNodes)
     );
     glb.downloadFiles();
 
@@ -202,7 +202,7 @@ export class GltfExportManager {
    * Prepares scene for GLB export.
    * This is very important for AR exports, since we have to do a lot of conversions to satisfy Apples .usdz format.
    */
-  protected async _exportPreProcess(optimizeForAR: boolean, excluded?: ExcludedGeometryList): Promise<void> {
+  protected async _exportPreProcess(optimizeForAR: boolean, excludeNodes?: NodeDescription[]): Promise<void> {
     if (!optimizeForAR) {
       // actually nothing to do if AR optimization is not required
       return;
@@ -235,7 +235,7 @@ export class GltfExportManager {
     // export
     this.viewer.scene.rootNodes
       // .filter(rootNode => rootNode.name !== GltfExportManager._EXPORT_ROOT_NAME)
-      .forEach(rootNode => this._prepareNodeForExport(rootNode, null, excluded));
+      .forEach(rootNode => this._prepareNodeForExport(rootNode, null, excludeNodes));
 
     // 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)
@@ -282,9 +282,9 @@ export class GltfExportManager {
   protected _prepareNodeForExport(
     node: Node,
     clonedParent: TransformNode | null,
-    excluded?: ExcludedGeometryList
+    excludeNodes?: NodeDescription[]
   ): void {
-    if (!GltfExportManager._shouldExportNode(node, excluded)) {
+    if (!GltfExportManager._shouldExportNode(node, excludeNodes)) {
       return;
     }
 
@@ -314,7 +314,7 @@ export class GltfExportManager {
 
     // handle children
     const childs = transformNode.getChildTransformNodes(true);
-    childs.forEach(child => this._prepareNodeForExport(child, clonedNode, excluded));
+    childs.forEach(child => this._prepareNodeForExport(child, clonedNode, excludeNodes));
   }
 
   /**

package/src/manager/html-anchor-manager.ts

@@ -13,6 +13,7 @@ import {
   Viewer,
   Viewport,
 } from '..';
+import { getInternalMetadataValue, setInternalMetadataValue } from '../internal/metadata-helper';
 import html2canvas from 'html2canvas';
 
 export type HtmlAnchorOptions = {
@@ -70,6 +71,15 @@ export class HtmlAnchorManager {
 
   protected _anchorMeshMaterial: StandardMaterial | null = null;
 
+  /**
+   * Check if input node is a html anchor mesh, created by this manager.\
+   * This check is done via internal metadata check.
+   * @internal
+   */
+  public static isHtmlAnchorMesh(node: TransformNode): boolean {
+    return !!getInternalMetadataValue(node, 'isHtmlAnchorMesh');
+  }
+
   /** @internal */
   public constructor(protected viewer: Viewer) {
     const canvas = viewer.canvas;
@@ -141,6 +151,7 @@ export class HtmlAnchorManager {
     // it's important that the occlusion check mesh is rendered after all "normal" meshes, which should be taken into
     // account for the occlusion check
     anchorMesh.renderingGroupId = 1;
+    setInternalMetadataValue(anchorMesh, 'isHtmlAnchorMesh', true);
 
     this._htmlAnchors[name] = { parentHtmlElement, anchorMesh, options };
   }
@@ -266,15 +277,6 @@ export class HtmlAnchorManager {
     return anchorKeys;
   }
 
-  /**
-   * Check if input mesh is a html anchor mesh, created by this manager.\
-   * This check is done via the material, as all html anchor meshes have the generic `_anchorMeshMaterial` set.
-   * @internal
-   */
-  public isHtmlAnchorMesh(mesh: AbstractMesh): boolean {
-    return !!this._anchorMeshMaterial && mesh.material === this._anchorMeshMaterial;
-  }
-
   protected _updateHtmlAnchor(
     parentHtmlElement: HTMLDivElement,
     anchorMesh: AbstractMesh,

package/src/manager/parameter-manager.ts

@@ -501,13 +501,17 @@ export class ParameterManager {
           const setMaterialProms = activatedNodes.map(async an => {
             const anVisibleNested = this.getNestedVisibilityParameterValueOfNode(an);
             const anDeferredMaterial = getInternalMetadataValue(an, 'deferredMaterial');
-            // skip applying material if it's already set via the parameter
             const anMaterialParamValue = this._getParameterValueOfNode(an, BuiltInParameter.Material) as
               | string
               | undefined;
-            if (anVisibleNested && anDeferredMaterial && !anMaterialParamValue) {
+            // get latest requested material, either from (new) parameter value or from deferred material
+            const anRequestedMaterial = anMaterialParamValue ?? anDeferredMaterial;
+            // material observer might have been executed before visibility observer
+            // => skip the material application in this case, as if it would be done twice
+            const anMaterialToBeSet = getInternalMetadataValue(an, 'materialToBeSet');
+            if (anVisibleNested && anRequestedMaterial && !anMaterialToBeSet) {
               await this.viewer.materialManager.setMaterialOnMesh(
-                anDeferredMaterial,
+                anRequestedMaterial,
                 // this cast is fine, as deferred material can only be set on meshes
                 an as AbstractMesh
               );
@@ -535,7 +539,12 @@ export class ParameterManager {
         // only set material if the mesh is visible, or gets visible by the parameter update
         const visible = this.getNestedVisibilityParameterValueOfNode(node);
         if (visible) {
-          await this.viewer.materialManager.setMaterialOnMesh(material, node);
+          // visibility observer might have been executed before material observer
+          // => skip the material application in this case, as if it would be done twice
+          const anMaterialToBeSet = getInternalMetadataValue(node, 'materialToBeSet');
+          if (!anMaterialToBeSet) {
+            await this.viewer.materialManager.setMaterialOnMesh(material, node);
+          }
         } else {
           setInternalMetadataValue(node, 'deferredMaterial', material);
         }

package/src/manager/scene-manager.ts

@@ -2,13 +2,12 @@ import {
   AbstractMesh,
   ArcRotateCamera,
   AssetContainer,
-  BackgroundMaterial,
   BoundingInfo,
   CameraManager,
   Color4,
   CubeTexture,
-  ExcludedGeometryList,
   IShadowGenerator,
+  NodeDescription,
   TransformNode,
   Vector3,
   Viewer,
@@ -16,7 +15,7 @@ import {
   ViewerErrorIds,
 } from '../index';
 import { BaseAsset, loadAsset, prepareAssetForScene } from '../internal/asset-helper';
-import { isNodeExcluded } from '../internal/geometry-helper';
+import { nodeMatchesAnyCriteria } from '../internal/node-helper';
 import { merge } from 'lodash-es';
 
 /**
@@ -63,9 +62,9 @@ export type UpdateGroundSettings = {
    */
   factor?: number;
   /**
-   * Optional list of geometry to be excluded from scene size calculation
+   * Optional list of nodes to be excluded from scene size calculation
    */
-  excludeGeometry?: ExcludedGeometryList;
+  excludeNodes?: NodeDescription[];
 };
 
 export type UpdateShadowsSettings = {
@@ -75,13 +74,13 @@ export type UpdateShadowsSettings = {
    */
   shadowGenerators?: IShadowGenerator[];
   /**
-   * Optional list of geometry which should not be defined as shadow caster
+   * Optional list of nodes which should not be defined as shadow caster
    */
-  excludeCaster?: ExcludedGeometryList;
+  excludeCasterNodes?: NodeDescription[];
   /**
-   * Optional list of geometry which should not be defined as shadow receiver
+   * Optional list of nodes which should not be defined as shadow receiver
    */
-  excludeReceiver?: ExcludedGeometryList;
+  excludeReceiverNodes?: NodeDescription[];
 };
 
 /**
@@ -277,36 +276,27 @@ export class SceneManager {
    * Calculates size of the current scene.\
    * Only takes meshes into considerations that:
    * - are visible
-   * - are not excluded by "excludeGeometry" parameter
+   * - are not excluded by "excludeNodes" parameter
    * - do not have a material of type "BackgroundMaterial"
    * - do not have an infinite distance (like sky boxes)
    */
-  public calculateBoundingInfo(excludeGeometry?: ExcludedGeometryList): BoundingInfo {
+  public calculateBoundingInfo(excludeNodes?: NodeDescription[]): BoundingInfo {
     // CB-6062: workaround for BoundingBox not respecting render loop
     this.viewer.scene.render();
 
     const { max, min } = this.viewer.scene.meshes
       .filter(mesh => {
-        const isEnabled = mesh.isEnabled();
-        // ignore meshes with invalid bounding infos
-        const hasValidBBoxInfo = mesh.getBoundingInfo().boundingSphere.radius > 0;
-        // ignore meshes with infinite distance, typically these are sky boxes
-        const hasInfiniteDistance = mesh.infiniteDistance;
-        // ignore meshes with "BackgroundMaterial" - usually a ground or skybox
-        const hasBackgroundMaterial = mesh.material instanceof BackgroundMaterial;
-        // ignore dummy meshes for html anchor occlusion check
-        const isHtmlAnchorMesh = this.viewer.htmlAnchorManager.isHtmlAnchorMesh(mesh);
         // ignore excluded meshes
-        const isExcluded = excludeGeometry ? isNodeExcluded(mesh, excludeGeometry) : false;
-
-        return (
-          isEnabled &&
-          hasValidBBoxInfo &&
-          !hasInfiniteDistance &&
-          !hasBackgroundMaterial &&
-          !isHtmlAnchorMesh &&
-          !isExcluded
-        );
+        const isExcluded = nodeMatchesAnyCriteria(mesh, {
+          isInList: excludeNodes,
+          isDisabled: true,
+          hasInvalidBoundingInfo: true,
+          hasInfiniteDistance: true,
+          isGeneratedBackgroundMesh: true,
+          isHtmlAnchorMesh: true,
+        });
+
+        return !isExcluded;
       })
       .reduce(
         (accBBoxMinMax, curMesh, idx) => {
@@ -331,7 +321,7 @@ export class SceneManager {
    * plane mesh can be used as well.
    */
   public updateGround(settings?: UpdateGroundSettings): void {
-    const bboxInfo = this.calculateBoundingInfo(settings?.excludeGeometry);
+    const bboxInfo = this.calculateBoundingInfo(settings?.excludeNodes);
 
     const groundMesh = settings?.groundMesh ?? this.viewer.scene.getMeshByName(SceneManager._DEFAULT_GROUND_PLANE_NAME);
     if (!groundMesh) {
@@ -343,7 +333,10 @@ export class SceneManager {
     const factor =
       bboxInfo.boundingSphere.radius * 2 * (settings?.factor ?? SceneManager._DEFAULT_GROUND_SIZING_FACTOR);
     const position = bboxInfo.boundingSphere.centerWorld;
-    groundMesh.scaling = new Vector3(factor, factor, 1);
+    // scale in all dimensions, in this case it doesn't matter in which coordinate space (XY, XZ) the ground has been
+    // built
+    // also the flat dimension of the plane is independent of the scaling, it will always remain a plane
+    groundMesh.scaling = new Vector3(factor, factor, factor);
     groundMesh.position = new Vector3(position.x, 0, position.z);
   }
 
@@ -358,16 +351,23 @@ export class SceneManager {
 
     const shadowCasterMeshes: AbstractMesh[] = [];
     this.viewer.scene.meshes.forEach(mesh => {
-      const isShadowReceiver = settings?.excludeReceiver ? !isNodeExcluded(mesh, settings.excludeReceiver) : true;
-      if (isShadowReceiver) {
-        mesh.receiveShadows = true;
-      }
+      mesh.receiveShadows = !nodeMatchesAnyCriteria(mesh, {
+        isInList: settings?.excludeReceiverNodes,
+        isHtmlAnchorMesh: true,
+        isDimensionLine: true,
+      });
 
-      // excluding background meshes like ground or walls from shadow casters is benefitial to reduce the size of the
+      // exclude "helper meshes" (e.g. skybox, ground, dimension lines, html anchors) here to reduce the size of the
       // poisson filters auto shadow plane calculation, which will result in better shadow resolution
-      const hasBackgroundMaterial = mesh.material instanceof BackgroundMaterial;
-      const isShadowCaster = settings?.excludeCaster ? !isNodeExcluded(mesh, settings.excludeCaster) : true;
-      if (isShadowCaster && !hasBackgroundMaterial) {
+      const excludeAsShadowCaster = nodeMatchesAnyCriteria(mesh, {
+        isInList: settings?.excludeCasterNodes,
+        hasInvalidBoundingInfo: true,
+        hasInfiniteDistance: true,
+        isGeneratedBackgroundMesh: true,
+        isHtmlAnchorMesh: true,
+        isDimensionLine: true,
+      });
+      if (!excludeAsShadowCaster) {
         shadowCasterMeshes.push(mesh);
       }
     });

package/src/viewer.ts

@@ -13,11 +13,12 @@ import {
   HtmlAnchorManager,
   MaterialManager,
   ModelManager,
+  NodeParameterSubject,
   NullEngine,
   ParameterManager,
-  ParameterSubject,
   Scene,
   SceneManager,
+  TagParameterSubject,
   TextureManager,
   TransformNode,
 } from './index';
@@ -26,10 +27,10 @@ import { getIsScaledDownDevice } from './internal/device-helper';
 import { cloneDeep, merge } from 'lodash-es';
 
 /**
- * Use this to define geometry to be excluded from autofocus, GLB export, etc.
+ * Use this type to select nodes directly or via node or tag name.\
+ * This pattern is used for excluding nodes from autofocus, GLB export, etc.
  */
-export type ExcludedGeometry = TransformNode | ParameterSubject;
-export type ExcludedGeometryList = ExcludedGeometry[];
+export type NodeDescription = TransformNode | TagParameterSubject | NodeParameterSubject;
 
 export type LimitTextureSizeConfig = {
   size: 512 | 1024;