Fix #3520

src/Actions/abstractActionManager.ts

@@ -20,6 +20,11 @@ export abstract class AbstractActionManager implements IDisposable {
     public actions = new Array<IAction>();
 
     /**
+     * Gets or sets a boolean indicating that the manager is recursive meaning that it can trigger action from children
+     */
+    public isRecursive = false;
+
+    /**
      * Releases all associated resources
      */
     public abstract dispose(): void;

src/Actions/action.ts

@@ -20,7 +20,7 @@ export interface IAction {
    */
     trigger: number;
 
-    /** the trigger, with or without parameters, for the action */
+    /** Options of the trigger */
     triggerOptions: any;
 
     /**

src/Meshes/abstractMesh.ts

@@ -659,6 +659,26 @@ export class AbstractMesh extends TransformNode implements IDisposable, ICullabl
     }
 
     /** @hidden */
+    public _getActionManagerForTrigger(trigger?: number, initialCall = true): Nullable<AbstractActionManager> {
+        if (this.actionManager && (initialCall || this.actionManager.isRecursive)) {
+            if (trigger) {
+                if (this.actionManager.hasSpecificTrigger(trigger)) {
+                    return this.actionManager;
+                }
+            }
+            else {
+                return this.actionManager;
+            }
+        }
+
+        if (!this.parent) {
+            return null;
+        }
+
+        return this.parent._getActionManagerForTrigger(trigger, false);
+    }
+
+    /** @hidden */
     public _rebuild(): void {
         this.onRebuildObservable.notifyObservers(this);
 

src/node.ts

@@ -7,6 +7,7 @@ import { serialize } from "./Misc/decorators";
 import { Observable, Observer } from "./Misc/observable";
 import { EngineStore } from "./Engines/engineStore";
 import { _DevTools } from './Misc/devTools';
+import { AbstractActionManager } from './Actions/abstractActionManager';
 
 declare type Animatable = import("./Animations/animatable").Animatable;
 declare type AnimationPropertiesOverride = import("./Animations/animationPropertiesOverride").AnimationPropertiesOverride;
@@ -402,6 +403,15 @@ export class Node implements IBehaviorAware<Node> {
         this._updateCache();
     }
 
+    /** @hidden */
+    public _getActionManagerForTrigger(trigger?: number, initialCall = true): Nullable<AbstractActionManager> {
+        if (!this.parent) {
+            return null;
+        }
+
+        return this.parent._getActionManagerForTrigger(trigger, false);
+    }
+
     // override it in derived class if you add new variables to the cache
     // and call the parent class method if !ignoreParentClass
     /** @hidden */

src/scene.ts

@@ -1792,14 +1792,17 @@ export class Scene extends AbstractScene implements IAnimatable {
                     this.onPointerObservable.notifyObservers(pi, type);
                 }
             }
-            if (pickResult.pickedMesh.actionManager && !clickInfo.ignore) {
-                pickResult.pickedMesh.actionManager.processTrigger(Constants.ACTION_OnPickUpTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
+            let actionManager = pickResult.pickedMesh._getActionManagerForTrigger();
+            if (actionManager && !clickInfo.ignore) {
+                actionManager.processTrigger(Constants.ACTION_OnPickUpTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
 
                 if (!clickInfo.hasSwiped && clickInfo.singleClick) {
-                    pickResult.pickedMesh.actionManager.processTrigger(Constants.ACTION_OnPickTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
+                    actionManager.processTrigger(Constants.ACTION_OnPickTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                 }
-                if (clickInfo.doubleClick && pickResult.pickedMesh.actionManager.hasSpecificTrigger(Constants.ACTION_OnDoublePickTrigger)) {
-                    pickResult.pickedMesh.actionManager.processTrigger(Constants.ACTION_OnDoublePickTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
+
+                let doubleClickActionManager = pickResult.pickedMesh._getActionManagerForTrigger(Constants.ACTION_OnDoublePickTrigger);
+                if (clickInfo.doubleClick && doubleClickActionManager) {
+                    doubleClickActionManager.processTrigger(Constants.ACTION_OnDoublePickTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                 }
             }
         }
@@ -1811,11 +1814,11 @@ export class Scene extends AbstractScene implements IAnimatable {
             }
         }
 
-        if (this._pickedDownMesh &&
-            this._pickedDownMesh.actionManager &&
-            this._pickedDownMesh.actionManager.hasSpecificTrigger(Constants.ACTION_OnPickOutTrigger) &&
-            this._pickedDownMesh !== this._pickedUpMesh) {
-            this._pickedDownMesh.actionManager.processTrigger(Constants.ACTION_OnPickOutTrigger, ActionEvent.CreateNew(this._pickedDownMesh, evt));
+        if (this._pickedDownMesh && this._pickedDownMesh !== this._pickedUpMesh) {
+            let pickedDownActionManager = this._pickedDownMesh._getActionManagerForTrigger(Constants.ACTION_OnPickOutTrigger);
+            if (pickedDownActionManager) {
+                pickedDownActionManager.processTrigger(Constants.ACTION_OnPickOutTrigger, ActionEvent.CreateNew(this._pickedDownMesh, evt));
+            }
         }
 
         let type = 0;
@@ -4789,13 +4792,20 @@ export class Scene extends AbstractScene implements IAnimatable {
             return;
         }
 
-        if (this._pointerOverMesh && this._pointerOverMesh.actionManager) {
-            this._pointerOverMesh.actionManager.processTrigger(Constants.ACTION_OnPointerOutTrigger, ActionEvent.CreateNew(this._pointerOverMesh));
+        let actionManager: Nullable<AbstractActionManager>;
+        if (this._pointerOverMesh) {
+            actionManager = this._pointerOverMesh._getActionManagerForTrigger(Constants.ACTION_OnPointerOutTrigger);
+            if (actionManager) {
+                actionManager.processTrigger(Constants.ACTION_OnPointerOutTrigger, ActionEvent.CreateNew(this._pointerOverMesh));
+            }
         }
 
         this._pointerOverMesh = mesh;
-        if (this._pointerOverMesh && this._pointerOverMesh.actionManager) {
-            this._pointerOverMesh.actionManager.processTrigger(Constants.ACTION_OnPointerOverTrigger, ActionEvent.CreateNew(this._pointerOverMesh));
+        if (this._pointerOverMesh) {
+            actionManager = this._pointerOverMesh._getActionManagerForTrigger(Constants.ACTION_OnPointerOverTrigger);
+            if (actionManager) {
+                actionManager.processTrigger(Constants.ACTION_OnPointerOverTrigger, ActionEvent.CreateNew(this._pointerOverMesh));
+            }
         }
     }