@babylonjs/core 6.23.1 → 6.25.0

package/scene.d.ts

@@ -2076,42 +2076,49 @@ export declare class Scene extends AbstractScene implements IAnimatable, IClipPl
     _rebuildGeometries(): void;
     /** @internal */
     _rebuildTextures(): void;
+    /**
+     * Get from a list of objects by tags
+     * @param list the list of objects to use
+     * @param tagsQuery the query to use
+     * @param filter a predicate to filter for tags
+     * @returns
+     */
     private _getByTags;
     /**
      * Get a list of meshes by tags
      * @param tagsQuery defines the tags query to use
-     * @param forEach defines a predicate used to filter results
+     * @param filter defines a predicate used to filter results
      * @returns an array of Mesh
      */
-    getMeshesByTags(tagsQuery: string, forEach?: (mesh: AbstractMesh) => void): Mesh[];
+    getMeshesByTags(tagsQuery: string, filter?: (mesh: AbstractMesh) => boolean): Mesh[];
     /**
      * Get a list of cameras by tags
      * @param tagsQuery defines the tags query to use
-     * @param forEach defines a predicate used to filter results
+     * @param filter defines a predicate used to filter results
      * @returns an array of Camera
      */
-    getCamerasByTags(tagsQuery: string, forEach?: (camera: Camera) => void): Camera[];
+    getCamerasByTags(tagsQuery: string, filter?: (camera: Camera) => boolean): Camera[];
     /**
      * Get a list of lights by tags
      * @param tagsQuery defines the tags query to use
-     * @param forEach defines a predicate used to filter results
+     * @param filter defines a predicate used to filter results
      * @returns an array of Light
      */
-    getLightsByTags(tagsQuery: string, forEach?: (light: Light) => void): Light[];
+    getLightsByTags(tagsQuery: string, filter?: (light: Light) => boolean): Light[];
     /**
      * Get a list of materials by tags
      * @param tagsQuery defines the tags query to use
-     * @param forEach defines a predicate used to filter results
+     * @param filter defines a predicate used to filter results
      * @returns an array of Material
      */
-    getMaterialByTags(tagsQuery: string, forEach?: (material: Material) => void): Material[];
+    getMaterialByTags(tagsQuery: string, filter?: (material: Material) => boolean): Material[];
     /**
      * Get a list of transform nodes by tags
      * @param tagsQuery defines the tags query to use
-     * @param forEach defines a predicate used to filter results
+     * @param filter defines a predicate used to filter results
      * @returns an array of TransformNode
      */
-    getTransformNodesByTags(tagsQuery: string, forEach?: (transform: TransformNode) => void): TransformNode[];
+    getTransformNodesByTags(tagsQuery: string, filter?: (transform: TransformNode) => boolean): TransformNode[];
     /**
      * Overrides the default sort function applied in the rendering group to prepare the meshes.
      * This allowed control for front to back rendering or reversly depending of the special needs.

package/scene.js

@@ -337,12 +337,7 @@ export class Scene extends AbstractScene {
      * @returns the computed eye position
      */
     bindEyePosition(effect, variableName = "vEyePosition", isVector3 = false) {
-        var _a;
-        const eyePosition = this._forcedViewPosition
-            ? this._forcedViewPosition
-            : this._mirroredCameraPosition
-                ? this._mirroredCameraPosition
-                : (_a = this.activeCamera.globalPosition) !== null && _a !== void 0 ? _a : this.activeCamera.devicePosition;
+        const eyePosition = this._forcedViewPosition ? this._forcedViewPosition : this._mirroredCameraPosition ? this._mirroredCameraPosition : this.activeCamera.globalPosition;
         const invertNormal = this.useRightHandedSystem === (this._mirroredCameraPosition != null);
         TmpVectors.Vector4[0].set(eyePosition.x, eyePosition.y, eyePosition.z, invertNormal ? -1 : 1);
         if (effect) {
@@ -4236,23 +4231,23 @@ export class Scene extends AbstractScene {
         }
         this.markAllMaterialsAsDirty(1);
     }
-    // Tags
-    _getByTags(list, tagsQuery, forEach) {
+    /**
+     * Get from a list of objects by tags
+     * @param list the list of objects to use
+     * @param tagsQuery the query to use
+     * @param filter a predicate to filter for tags
+     * @returns
+     */
+    _getByTags(list, tagsQuery, filter) {
         if (tagsQuery === undefined) {
             // returns the complete list (could be done with Tags.MatchesQuery but no need to have a for-loop here)
             return list;
         }
         const listByTags = [];
-        forEach =
-            forEach ||
-                ((item) => {
-                    return;
-                });
         for (const i in list) {
             const item = list[i];
-            if (Tags && Tags.MatchesQuery(item, tagsQuery)) {
+            if (Tags && Tags.MatchesQuery(item, tagsQuery) && (!filter || filter(item))) {
                 listByTags.push(item);
-                forEach(item);
             }
         }
         return listByTags;
@@ -4260,47 +4255,47 @@ export class Scene extends AbstractScene {
     /**
      * Get a list of meshes by tags
      * @param tagsQuery defines the tags query to use
-     * @param forEach defines a predicate used to filter results
+     * @param filter defines a predicate used to filter results
      * @returns an array of Mesh
      */
-    getMeshesByTags(tagsQuery, forEach) {
-        return this._getByTags(this.meshes, tagsQuery, forEach);
+    getMeshesByTags(tagsQuery, filter) {
+        return this._getByTags(this.meshes, tagsQuery, filter);
     }
     /**
      * Get a list of cameras by tags
      * @param tagsQuery defines the tags query to use
-     * @param forEach defines a predicate used to filter results
+     * @param filter defines a predicate used to filter results
      * @returns an array of Camera
      */
-    getCamerasByTags(tagsQuery, forEach) {
-        return this._getByTags(this.cameras, tagsQuery, forEach);
+    getCamerasByTags(tagsQuery, filter) {
+        return this._getByTags(this.cameras, tagsQuery, filter);
     }
     /**
      * Get a list of lights by tags
      * @param tagsQuery defines the tags query to use
-     * @param forEach defines a predicate used to filter results
+     * @param filter defines a predicate used to filter results
      * @returns an array of Light
      */
-    getLightsByTags(tagsQuery, forEach) {
-        return this._getByTags(this.lights, tagsQuery, forEach);
+    getLightsByTags(tagsQuery, filter) {
+        return this._getByTags(this.lights, tagsQuery, filter);
     }
     /**
      * Get a list of materials by tags
      * @param tagsQuery defines the tags query to use
-     * @param forEach defines a predicate used to filter results
+     * @param filter defines a predicate used to filter results
      * @returns an array of Material
      */
-    getMaterialByTags(tagsQuery, forEach) {
-        return this._getByTags(this.materials, tagsQuery, forEach).concat(this._getByTags(this.multiMaterials, tagsQuery, forEach));
+    getMaterialByTags(tagsQuery, filter) {
+        return this._getByTags(this.materials, tagsQuery, filter).concat(this._getByTags(this.multiMaterials, tagsQuery, filter));
     }
     /**
      * Get a list of transform nodes by tags
      * @param tagsQuery defines the tags query to use
-     * @param forEach defines a predicate used to filter results
+     * @param filter defines a predicate used to filter results
      * @returns an array of TransformNode
      */
-    getTransformNodesByTags(tagsQuery, forEach) {
-        return this._getByTags(this.transformNodes, tagsQuery, forEach);
+    getTransformNodesByTags(tagsQuery, filter) {
+        return this._getByTags(this.transformNodes, tagsQuery, filter);
     }
     /**
      * Overrides the default sort function applied in the rendering group to prepare the meshes.