@combeenation/3d-viewer 20.0.0-alpha1 → 20.0.0-beta1

package/src/manager/scene-manager.ts

@@ -83,6 +83,16 @@ export type UpdateShadowsSettings = {
   excludeReceiverNodes?: NodeDescription[];
 };
 
+export type CalculateBoundingInfoSettings = {
+  /** Optional list of nodes to be excluded from bounding info calculation */
+  excludeNodes?: NodeDescription[];
+  /**
+   * Defines if HTML anchors should be considered for the bounding info calculation.\
+   * Default: `true`
+   */
+  excludeHtmlAnchors?: boolean;
+};
+
 /**
  * Additional scene settings, which are not available in a basic `AssetContainer`.
  * !!! IMPORTANT when adding a new property !!!
@@ -104,6 +114,8 @@ type SceneAsset = BaseAsset & {
  * This contains creating or loading scenes with certain settings for lighting, cameras and appearance in genereal.
  */
 export class SceneManager {
+  protected static _DEFAULT_SCENE_ASSET_ENVIRONMENT_URL =
+    'https://cbnpeuwstservice.blob.core.windows.net/viewer3d/static/studio.env';
   protected static _DEFAULT_SCENE_ASSET_NAME = '$defaultScene';
   protected static _DEFAULT_GROUND_PLANE_NAME = 'BackgroundPlane';
   protected static _DEFAULT_GROUND_SIZING_FACTOR = 5;
@@ -125,7 +137,7 @@ export class SceneManager {
 
     environment: {
       create: true,
-      url: 'https://assets.babylonjs.com/environments/environmentSpecular.env',
+      url: SceneManager._DEFAULT_SCENE_ASSET_ENVIRONMENT_URL,
       intensity: 1,
     },
   };
@@ -280,7 +292,9 @@ export class SceneManager {
    * - do not have a material of type "BackgroundMaterial"
    * - do not have an infinite distance (like sky boxes)
    */
-  public calculateBoundingInfo(excludeNodes?: NodeDescription[]): BoundingInfo {
+  public calculateBoundingInfo(settings?: CalculateBoundingInfoSettings): BoundingInfo {
+    const { excludeNodes, excludeHtmlAnchors } = settings ?? {};
+
     // CB-6062: workaround for BoundingBox not respecting render loop
     this.viewer.scene.render();
 
@@ -293,7 +307,7 @@ export class SceneManager {
           hasInvalidBoundingInfo: true,
           hasInfiniteDistance: true,
           isGeneratedBackgroundMesh: true,
-          isHtmlAnchorMesh: true,
+          isHtmlAnchorMesh: excludeHtmlAnchors !== false,
         });
 
         return !isExcluded;
@@ -321,7 +335,7 @@ export class SceneManager {
    * plane mesh can be used as well.
    */
   public updateGround(settings?: UpdateGroundSettings): void {
-    const bboxInfo = this.calculateBoundingInfo(settings?.excludeNodes);
+    const bboxInfo = this.calculateBoundingInfo({ excludeNodes: settings?.excludeNodes });
 
     const groundMesh = settings?.groundMesh ?? this.viewer.scene.getMeshByName(SceneManager._DEFAULT_GROUND_PLANE_NAME);
     if (!groundMesh) {

package/src/utils/viewer-utils.ts

@@ -4,6 +4,8 @@ import {
   Mesh,
   MorphTarget,
   MorphTargetManager,
+  Node,
+  Tags,
   TransformNode,
   Vector3,
   VertexBuffer,
@@ -13,6 +15,7 @@ import {
 export type BakeGeometrySettings = {
   keepTransformation?: boolean;
 };
+
 export type CreateTransformNodeSettings = {
   parentNode?: TransformNode;
   position?: Vector3;
@@ -20,6 +23,34 @@ export type CreateTransformNodeSettings = {
   scaling?: Vector3;
 };
 
+/**
+ * Expected metadata structure for find node functions {@link ViewerUtils.findChildNodes} and
+ * {@link ViewerUtils.findParentNode}
+ */
+export type MetadataObject = Record<string, unknown>;
+
+/**
+ * Contains all constructor that derive from `Node`, e.g. `TransformNode`, `Mesh`
+ */
+export type DerivedNodeType<T extends Node> = new (...args: any[]) => T;
+
+/**
+ * Criteria object for find node functions {@link ViewerUtils.findChildNodes} and {@link ViewerUtils.findParentNode}.\
+ * If property is omitted, the dedicated filter passes.
+ *
+ * @param nodeName has to match exactly
+ * @param tagName uses algorithm of `Tags.MatchesQuery`, in most cases this is just an exact string match check
+ * @param metadataObject has to be an object, filter passes if all property values of the given input object match the
+ *                       checked node
+ * @param type nodes type has to match (e.g. Mesh)
+ */
+export type FindNodeCriteria<T extends Node> = {
+  nodeName?: string;
+  tagName?: string;
+  metadataObject?: MetadataObject;
+  type?: DerivedNodeType<T>;
+};
+
 export class ViewerUtils {
   /** @internal */
   public constructor(protected viewer: Viewer) {}
@@ -99,6 +130,41 @@ export class ViewerUtils {
     return node;
   }
 
+  /**
+   * Finds all child nodes (TransformNodes, Meshes, but also Lights, Cameras, etc...) that match a given criteria.
+   *
+   * @param node If left empty, all nodes of the scene are considered
+   * @param criteria If left empty, all child nodes are returned
+   */
+  public findChildNodes<T extends Node>(node?: Node, criteria?: FindNodeCriteria<T>): T[] {
+    const allNodes = node ? node.getChildren(undefined, false) : [...this.viewer.scene.getNodes()];
+
+    if (!criteria) return allNodes as T[];
+
+    const foundNodes = allNodes.filter(node => this._matchesFindNodeCriteria(node, criteria));
+    return foundNodes as T[];
+  }
+
+  /**
+   * Finds nearest node that matches a given criteria.\
+   * Returns `undefined` if no node could be found.
+   */
+  public findParentNode<T extends Node>(node: Node, criteria?: FindNodeCriteria<T>): T | undefined {
+    const parent = node.parent;
+    if (!parent) {
+      return undefined;
+    } else if (!criteria) {
+      return parent as T;
+    }
+
+    const matchesCriteria = this._matchesFindNodeCriteria(parent, criteria);
+    if (matchesCriteria) {
+      return parent as T;
+    } else {
+      return this.findParentNode(parent, criteria);
+    }
+  }
+
   /**
    * @param kind morph targets can affect various vertices kinds, whereas "position" is the most common one
    * still other kinds (like normals or tangents) can be affected as well and can be provided on this input
@@ -146,4 +212,22 @@ export class ViewerUtils {
 
     return null;
   }
+
+  protected _matchesFindNodeCriteria<T extends Node>(node: Node, criteria?: FindNodeCriteria<T>): boolean {
+    if (!criteria) return true;
+
+    const { nodeName, tagName, metadataObject, type } = criteria;
+    const nodeNameFits = !nodeName || node.name === nodeName;
+    const tagNameFits = !tagName || Tags.MatchesQuery(node, tagName);
+    const metadataFits = !metadataObject || this._matchesMetadata(node.metadata, metadataObject);
+    const typeFits = !type || node instanceof type;
+
+    return nodeNameFits && tagNameFits && metadataFits && typeFits;
+  }
+
+  protected _matchesMetadata(metadata: unknown, filter: MetadataObject): boolean {
+    if (!metadata || typeof metadata !== 'object') return false;
+
+    return Object.entries(filter).every(([key, value]) => (metadata as MetadataObject)[key] === value);
+  }
 }