Action cir dep'

src/Actions/action.ts

@@ -1,12 +1,15 @@
 import { Observable } from "Tools/observable";
 import { Vector2, Vector3, Color3, Color4 } from "Math/math";
-import { Scene } from "scene";
-import { Mesh } from "Mesh/mesh";
-import { Light } from "Lights/light";
-import { Camera } from "Cameras/camera";
-import { Node } from "node";
-import { ActionManager, ActionEvent } from "./actionManager";
 import { Condition } from "./condition";
+
+declare type Scene = import("scene").Scene;
+declare type ActionManager = import("./actionManager").ActionManager;
+declare type ActionEvent = import("./actionEvent").ActionEvent;
+declare type Mesh = import("Mesh/mesh").Mesh;
+declare type Light = import("Lights/light").Light;
+declare type Camera = import("Cameras/camera").Camera;
+declare type Node = import("node").Node;
+
     /**
      * The action to be carried out following a trigger
      * @see http://doc.babylonjs.com/how_to/how_to_use_actions#available-actions
@@ -236,11 +239,11 @@ import { Condition } from "./condition";
         public static _GetTargetProperty = (target: Scene | Node) => {
             return {
                 name: "target",
-                targetType: target instanceof Mesh ? "MeshProperties"
-                            : target instanceof Light ? "LightProperties"
-                            : target instanceof Camera ? "CameraProperties"
+                targetType: (<Mesh>target)._isMesh ? "MeshProperties"
+                            : (<Light>target)._isLight ? "LightProperties"
+                            : (<Camera>target)._isCamera ? "CameraProperties"
                             : "SceneProperties",
-                value: target instanceof Scene ? "Scene" : (<Node>target).name
+                value: (<Scene>target)._isScene ? "Scene" : (<Node>target).name
             };
         }
     }

src/Actions/actionEvent.ts

@@ -0,0 +1,81 @@
+import { AbstractMesh } from "Mesh/abstractMesh";
+import { Nullable } from "types";
+import { Sprite } from "Sprites/sprite";
+import { Scene } from "scene";
+import { Vector2 } from "Math/math";
+
+    /**
+     * ActionEvent is the event being sent when an action is triggered.
+     */
+    export class ActionEvent {
+        /**
+         * Creates a new ActionEvent
+         * @param source The mesh or sprite that triggered the action
+         * @param pointerX The X mouse cursor position at the time of the event
+         * @param pointerY The Y mouse cursor position at the time of the event
+         * @param meshUnderPointer The mesh that is currently pointed at (can be null)
+         * @param sourceEvent the original (browser) event that triggered the ActionEvent
+         * @param additionalData additional data for the event
+         */
+        constructor(
+            /** The mesh or sprite that triggered the action */
+            public source: any,
+            /** The X mouse cursor position at the time of the event */
+            public pointerX: number,
+            /** The Y mouse cursor position at the time of the event */
+            public pointerY: number,
+            /** The mesh that is currently pointed at (can be null) */
+            public meshUnderPointer: Nullable<AbstractMesh>,
+            /** the original (browser) event that triggered the ActionEvent */
+            public sourceEvent?: any,
+            /** additional data for the event */
+            public additionalData?: any) {
+
+        }
+
+        /**
+         * Helper function to auto-create an ActionEvent from a source mesh.
+         * @param source The source mesh that triggered the event
+         * @param evt The original (browser) event
+         * @param additionalData additional data for the event
+         * @returns the new ActionEvent
+         */
+        public static CreateNew(source: AbstractMesh, evt?: Event, additionalData?: any): ActionEvent {
+            var scene = source.getScene();
+            return new ActionEvent(source, scene.pointerX, scene.pointerY, scene.meshUnderPointer, evt, additionalData);
+        }
+
+        /**
+         * Helper function to auto-create an ActionEvent from a source sprite
+         * @param source The source sprite that triggered the event
+         * @param scene Scene associated with the sprite
+         * @param evt The original (browser) event
+         * @param additionalData additional data for the event
+         * @returns the new ActionEvent
+         */
+        public static CreateNewFromSprite(source: Sprite, scene: Scene, evt?: Event, additionalData?: any): ActionEvent {
+            return new ActionEvent(source, scene.pointerX, scene.pointerY, scene.meshUnderPointer, evt, additionalData);
+        }
+
+        /**
+         * Helper function to auto-create an ActionEvent from a scene. If triggered by a mesh use ActionEvent.CreateNew
+         * @param scene the scene where the event occurred
+         * @param evt The original (browser) event
+         * @returns the new ActionEvent
+         */
+        public static CreateNewFromScene(scene: Scene, evt: Event): ActionEvent {
+            return new ActionEvent(null, scene.pointerX, scene.pointerY, scene.meshUnderPointer, evt);
+        }
+
+        /**
+         * Helper function to auto-create an ActionEvent from a primitive
+         * @param prim defines the target primitive
+         * @param pointerPos defines the pointer position
+         * @param evt The original (browser) event
+         * @param additionalData additional data for the event
+         * @returns the new ActionEvent
+         */
+        public static CreateNewFromPrimitive(prim: any, pointerPos: Vector2, evt?: Event, additionalData?: any): ActionEvent {
+            return new ActionEvent(prim, pointerPos.x, pointerPos.y, null, evt, additionalData);
+        }
+    }

src/Actions/actionManager.ts

@@ -1,91 +1,16 @@
 import { Nullable } from "types";
 import { AbstractMesh } from "Mesh/abstractMesh";
-import { Sprite } from "Sprites/sprite";
 import { Scene } from "scene";
-import { Vector2, Vector3, Vector4, Color3, Color4 } from "Math/math";
+import { Vector3, Vector4, Color3, Color4 } from "Math/math";
 
 import { Condition, ValueCondition } from "./condition";
 import { Action } from "./action";
 import { DoNothingAction } from "./directActions";
 
 import { Engine } from "Engine/engine";
+import { Constants } from "Engine/constants";
 import { Tools } from "Tools/tools";
-
-    /**
-     * ActionEvent is the event being sent when an action is triggered.
-     */
-    export class ActionEvent {
-        /**
-         * Creates a new ActionEvent
-         * @param source The mesh or sprite that triggered the action
-         * @param pointerX The X mouse cursor position at the time of the event
-         * @param pointerY The Y mouse cursor position at the time of the event
-         * @param meshUnderPointer The mesh that is currently pointed at (can be null)
-         * @param sourceEvent the original (browser) event that triggered the ActionEvent
-         * @param additionalData additional data for the event
-         */
-        constructor(
-            /** The mesh or sprite that triggered the action */
-            public source: any,
-            /** The X mouse cursor position at the time of the event */
-            public pointerX: number,
-            /** The Y mouse cursor position at the time of the event */
-            public pointerY: number,
-            /** The mesh that is currently pointed at (can be null) */
-            public meshUnderPointer: Nullable<AbstractMesh>,
-            /** the original (browser) event that triggered the ActionEvent */
-            public sourceEvent?: any,
-            /** additional data for the event */
-            public additionalData?: any) {
-
-        }
-
-        /**
-         * Helper function to auto-create an ActionEvent from a source mesh.
-         * @param source The source mesh that triggered the event
-         * @param evt The original (browser) event
-         * @param additionalData additional data for the event
-         * @returns the new ActionEvent
-         */
-        public static CreateNew(source: AbstractMesh, evt?: Event, additionalData?: any): ActionEvent {
-            var scene = source.getScene();
-            return new ActionEvent(source, scene.pointerX, scene.pointerY, scene.meshUnderPointer, evt, additionalData);
-        }
-
-        /**
-         * Helper function to auto-create an ActionEvent from a source sprite
-         * @param source The source sprite that triggered the event
-         * @param scene Scene associated with the sprite
-         * @param evt The original (browser) event
-         * @param additionalData additional data for the event
-         * @returns the new ActionEvent
-         */
-        public static CreateNewFromSprite(source: Sprite, scene: Scene, evt?: Event, additionalData?: any): ActionEvent {
-            return new ActionEvent(source, scene.pointerX, scene.pointerY, scene.meshUnderPointer, evt, additionalData);
-        }
-
-        /**
-         * Helper function to auto-create an ActionEvent from a scene. If triggered by a mesh use ActionEvent.CreateNew
-         * @param scene the scene where the event occurred
-         * @param evt The original (browser) event
-         * @returns the new ActionEvent
-         */
-        public static CreateNewFromScene(scene: Scene, evt: Event): ActionEvent {
-            return new ActionEvent(null, scene.pointerX, scene.pointerY, scene.meshUnderPointer, evt);
-        }
-
-        /**
-         * Helper function to auto-create an ActionEvent from a primitive
-         * @param prim defines the target primitive
-         * @param pointerPos defines the pointer position
-         * @param evt The original (browser) event
-         * @param additionalData additional data for the event
-         * @returns the new ActionEvent
-         */
-        public static CreateNewFromPrimitive(prim: any, pointerPos: Vector2, evt?: Event, additionalData?: any): ActionEvent {
-            return new ActionEvent(prim, pointerPos.x, pointerPos.y, null, evt, additionalData);
-        }
-    }
+import { ActionEvent } from "Actions/actionEvent";
 
     /**
      * Action Manager manages all events to be triggered on a given mesh or the global scene.
@@ -97,96 +22,96 @@ import { Tools } from "Tools/tools";
          * Nothing
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly NothingTrigger = 0;
+        public static readonly NothingTrigger = Constants.ACTION_NothingTrigger;
 
         /**
          * On pick
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly OnPickTrigger = 1;
+        public static readonly OnPickTrigger = Constants.ACTION_OnPickTrigger;
 
         /**
          * On left pick
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly OnLeftPickTrigger  = 2;
+        public static readonly OnLeftPickTrigger  = Constants.ACTION_OnLeftPickTrigger;
 
         /**
          * On right pick
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly OnRightPickTrigger = 3;
+        public static readonly OnRightPickTrigger = Constants.ACTION_OnRightPickTrigger;
 
         /**
          * On center pick
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly OnCenterPickTrigger = 4;
+        public static readonly OnCenterPickTrigger = Constants.ACTION_OnCenterPickTrigger;
 
         /**
          * On pick down
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly OnPickDownTrigger = 5;
+        public static readonly OnPickDownTrigger = Constants.ACTION_OnPickDownTrigger;
 
         /**
          * On double pick
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly OnDoublePickTrigger = 6;
+        public static readonly OnDoublePickTrigger = Constants.ACTION_OnDoublePickTrigger;
 
         /**
          * On pick up
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly OnPickUpTrigger = 7;
+        public static readonly OnPickUpTrigger = Constants.ACTION_OnPickUpTrigger;
         /**
          * On pick out.
          * This trigger will only be raised if you also declared a OnPickDown
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly OnPickOutTrigger = 16;
+        public static readonly OnPickOutTrigger = Constants.ACTION_OnPickOutTrigger;
 
         /**
          * On long press
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly OnLongPressTrigger = 8;
+        public static readonly OnLongPressTrigger = Constants.ACTION_OnLongPressTrigger;
 
         /**
          * On pointer over
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly OnPointerOverTrigger = 9;
+        public static readonly OnPointerOverTrigger = Constants.ACTION_OnPointerOverTrigger;
 
         /**
          * On pointer out
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly OnPointerOutTrigger = 10;
+        public static readonly OnPointerOutTrigger = Constants.ACTION_OnPointerOutTrigger;
 
         /**
          * On every frame
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly OnEveryFrameTrigger = 11;
+        public static readonly OnEveryFrameTrigger = Constants.ACTION_OnEveryFrameTrigger;
         /**
          * On intersection enter
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly OnIntersectionEnterTrigger = 12;
+        public static readonly OnIntersectionEnterTrigger = Constants.ACTION_OnIntersectionEnterTrigger;
 
         /**
          * On intersection exit
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly OnIntersectionExitTrigger = 13;
+        public static readonly OnIntersectionExitTrigger = Constants.ACTION_OnIntersectionExitTrigger;
 
         /**
          * On key down
          * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
          */
-        public static readonly OnKeyDownTrigger = 14;
+        public static readonly OnKeyDownTrigger = Constants.ACTION_OnKeyDownTrigger;
 
         /**
          * On key up

src/Actions/condition.ts

@@ -1,6 +1,7 @@
-import { ActionManager } from "./actionManager";
 import { Action } from "./action";
 
+declare type ActionManager = import("./actionManager").ActionManager;
+
     /**
      * A Condition applied to an Action
      */

src/Actions/directActions.ts

@@ -1,9 +1,10 @@
+import { Tools } from "Tools/tools";
+import { Vector3 } from "Math/math";
 import { Action } from "./action";
 import { Condition } from "./condition";
-import { ActionManager, ActionEvent } from "./actionManager";
+import { Constants } from "Engine/constants";
 
-import { Tools } from "Tools/tools";
-import { Vector3 } from "Math/math";
+declare type ActionEvent = import("./actionEvent").ActionEvent;
 
     /**
      * This defines an action responsible to toggle a boolean once triggered.
@@ -374,7 +375,7 @@ import { Vector3 } from "Math/math";
          * @param triggerOptions defines the trigger options
          * @param condition defines the trigger related conditions
          */
-        constructor(triggerOptions: any = ActionManager.NothingTrigger, condition?: Condition) {
+        constructor(triggerOptions: any = Constants.ACTION_NothingTrigger, condition?: Condition) {
             super(triggerOptions, condition);
         }
 

src/Cameras/camera.ts

@@ -354,6 +354,9 @@ declare type TargetCamera = import("./targetCamera").TargetCamera;
             return "Camera";
         }
 
+        /** @hidden */
+        public readonly _isCamera = true;
+
         /**
          * Gets a string representation of the camera usefull for debug purpose.
          * @param fullDetails Defines that a more verboe level of logging is required

src/Engine/constants.ts

@@ -230,4 +230,105 @@ export class Constants {
      * The all dirty flag value
      */
     public static readonly MATERIAL_AllDirtyFlag = 31;
+
+    /**
+     * Nothing
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_NothingTrigger = 0;
+
+    /**
+     * On pick
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnPickTrigger = 1;
+
+    /**
+     * On left pick
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnLeftPickTrigger  = 2;
+
+    /**
+     * On right pick
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnRightPickTrigger = 3;
+
+    /**
+     * On center pick
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnCenterPickTrigger = 4;
+
+    /**
+     * On pick down
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnPickDownTrigger = 5;
+
+    /**
+     * On double pick
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnDoublePickTrigger = 6;
+
+    /**
+     * On pick up
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnPickUpTrigger = 7;
+    /**
+     * On pick out.
+     * This trigger will only be raised if you also declared a OnPickDown
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnPickOutTrigger = 16;
+
+    /**
+     * On long press
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnLongPressTrigger = 8;
+
+    /**
+     * On pointer over
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnPointerOverTrigger = 9;
+
+    /**
+     * On pointer out
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnPointerOutTrigger = 10;
+
+    /**
+     * On every frame
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnEveryFrameTrigger = 11;
+    /**
+     * On intersection enter
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnIntersectionEnterTrigger = 12;
+
+    /**
+     * On intersection exit
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnIntersectionExitTrigger = 13;
+
+    /**
+     * On key down
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnKeyDownTrigger = 14;
+
+    /**
+     * On key up
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#triggers
+     */
+    public static readonly ACTION_OnKeyUpTrigger = 15;
 }

src/Lights/light.ts

@@ -368,6 +368,9 @@ import { IShadowGenerator } from "./Shadows/shadowGenerator";
             return "Light";
         }
 
+        /** @hidden */
+        public readonly _isLight = true;
+
         /**
          * Converts the light information to a readable string for debug purpose.
          * @param fullDetails Supports for multiple levels of logging within scene loading

src/Mesh/mesh.ts

@@ -418,6 +418,9 @@ declare type GroundMesh = import("./groundMesh").GroundMesh;
             return "Mesh";
         }
 
+        /** @hidden */
+        public readonly _isMesh = true;
+
         /**
          * Returns a description of this mesh
          * @param fullDetails define if full details about this mesh must be used

src/PostProcess/depthOfFieldBlurPostProcess.ts

@@ -2,7 +2,7 @@ import { Nullable } from "types";
 import { Vector2 } from "Math/math";
 import { Camera } from "Cameras/camera";
 import { Effect } from "Materials/effect";
-import { Texture } from "Materials/Textures";
+import { Texture } from "Materials/Textures/texture";
 import { PostProcess, PostProcessOptions } from "./postProcess";
 import { BlurPostProcess } from "./blurPostProcess";
 import { Engine } from "Engine/engine";

src/Sprites/spriteSceneComponent.ts

@@ -7,7 +7,8 @@ import { Ray } from "Culling/ray";
 import { Camera } from "Cameras/camera";
 import { PickingInfo } from "Collisions/pickingInfo";
 import { ISceneComponent, SceneComponentConstants } from "sceneComponent";
-import { ActionManager, ActionEvent } from "Actions/actionManager";
+import { ActionEvent } from "Actions/actionEvent";
+import { Constants } from "Engine/constants";
 
 declare module "scene" {
     export interface Scene {
@@ -145,12 +146,12 @@ declare module "scene" {
         }
 
         if (this._pointerOverSprite && this._pointerOverSprite.actionManager) {
-            this._pointerOverSprite.actionManager.processTrigger(ActionManager.OnPointerOutTrigger, ActionEvent.CreateNewFromSprite(this._pointerOverSprite, this));
+            this._pointerOverSprite.actionManager.processTrigger(Constants.ACTION_OnPointerOutTrigger, ActionEvent.CreateNewFromSprite(this._pointerOverSprite, this));
         }
 
         this._pointerOverSprite = sprite;
         if (this._pointerOverSprite && this._pointerOverSprite.actionManager) {
-            this._pointerOverSprite.actionManager.processTrigger(ActionManager.OnPointerOverTrigger, ActionEvent.CreateNewFromSprite(this._pointerOverSprite, this));
+            this._pointerOverSprite.actionManager.processTrigger(Constants.ACTION_OnPointerOverTrigger, ActionEvent.CreateNewFromSprite(this._pointerOverSprite, this));
         }
     };
 
@@ -265,17 +266,17 @@ declare module "scene" {
                         scene._pickedDownSprite = pickResult.pickedSprite;
                         switch (evt.button) {
                             case 0:
-                                pickResult.pickedSprite.actionManager.processTrigger(ActionManager.OnLeftPickTrigger, ActionEvent.CreateNewFromSprite(pickResult.pickedSprite, scene, evt));
+                                pickResult.pickedSprite.actionManager.processTrigger(Constants.ACTION_OnLeftPickTrigger, ActionEvent.CreateNewFromSprite(pickResult.pickedSprite, scene, evt));
                                 break;
                             case 1:
-                                pickResult.pickedSprite.actionManager.processTrigger(ActionManager.OnCenterPickTrigger, ActionEvent.CreateNewFromSprite(pickResult.pickedSprite, scene, evt));
+                                pickResult.pickedSprite.actionManager.processTrigger(Constants.ACTION_OnCenterPickTrigger, ActionEvent.CreateNewFromSprite(pickResult.pickedSprite, scene, evt));
                                 break;
                             case 2:
-                                pickResult.pickedSprite.actionManager.processTrigger(ActionManager.OnRightPickTrigger, ActionEvent.CreateNewFromSprite(pickResult.pickedSprite, scene, evt));
+                                pickResult.pickedSprite.actionManager.processTrigger(Constants.ACTION_OnRightPickTrigger, ActionEvent.CreateNewFromSprite(pickResult.pickedSprite, scene, evt));
                                 break;
                         }
                         if (pickResult.pickedSprite.actionManager) {
-                            pickResult.pickedSprite.actionManager.processTrigger(ActionManager.OnPickDownTrigger, ActionEvent.CreateNewFromSprite(pickResult.pickedSprite, scene, evt));
+                            pickResult.pickedSprite.actionManager.processTrigger(Constants.ACTION_OnPickDownTrigger, ActionEvent.CreateNewFromSprite(pickResult.pickedSprite, scene, evt));
                         }
                     }
                 }
@@ -292,16 +293,16 @@ declare module "scene" {
                 if (spritePickResult) {
                     if (spritePickResult.hit && spritePickResult.pickedSprite) {
                         if (spritePickResult.pickedSprite.actionManager) {
-                            spritePickResult.pickedSprite.actionManager.processTrigger(ActionManager.OnPickUpTrigger, ActionEvent.CreateNewFromSprite(spritePickResult.pickedSprite, scene, evt));
+                            spritePickResult.pickedSprite.actionManager.processTrigger(Constants.ACTION_OnPickUpTrigger, ActionEvent.CreateNewFromSprite(spritePickResult.pickedSprite, scene, evt));
                             if (spritePickResult.pickedSprite.actionManager) {
                                 if (!this.scene._isPointerSwiping()) {
-                                    spritePickResult.pickedSprite.actionManager.processTrigger(ActionManager.OnPickTrigger, ActionEvent.CreateNewFromSprite(spritePickResult.pickedSprite, scene, evt));
+                                    spritePickResult.pickedSprite.actionManager.processTrigger(Constants.ACTION_OnPickTrigger, ActionEvent.CreateNewFromSprite(spritePickResult.pickedSprite, scene, evt));
                                 }
                             }
                         }
                     }
                     if (scene._pickedDownSprite && scene._pickedDownSprite.actionManager && scene._pickedDownSprite !== spritePickResult.pickedSprite) {
-                        scene._pickedDownSprite.actionManager.processTrigger(ActionManager.OnPickOutTrigger, ActionEvent.CreateNewFromSprite(scene._pickedDownSprite, scene, evt));
+                        scene._pickedDownSprite.actionManager.processTrigger(Constants.ACTION_OnPickOutTrigger, ActionEvent.CreateNewFromSprite(scene._pickedDownSprite, scene, evt));
                     }
                 }
             }

src/node.ts

@@ -226,6 +226,9 @@ declare type AbstractMesh = import("Mesh/abstractMesh").AbstractMesh;
             return "Node";
         }
 
+        /** @hidden */
+        public readonly _isNode = true;
+
         /**
         * An event triggered when the mesh is disposed
         */

src/scene.ts

@@ -36,8 +36,10 @@ import { Collider } from "Collisions/collider";
 import { ICollisionCoordinator, CollisionCoordinatorLegacy } from "Collisions/collisionCoordinator";
 import { PointerEventTypes, PointerInfoPre, PointerInfo } from "Events/pointerEvents";
 import { KeyboardInfoPre, KeyboardInfo, KeyboardEventTypes } from "Events/keyboardEvents";
-import { ActionManager, ActionEvent } from "Actions/actionManager";
-import { PostProcess, PostProcessManager } from "PostProcess";
+import { ActionEvent } from "Actions/actionEvent";
+import { ActionManager } from "Actions/actionManager";
+import { PostProcess } from "PostProcess/postProcess";
+import { PostProcessManager } from "PostProcess/postProcessManager";
 import { IOfflineProvider } from "Offline/IOfflineProvider";
 import { RenderingManager, IRenderingManagerAutoClearSetup } from "Rendering/renderingManager";
 import { ISceneComponent, ISceneSerializableComponent, Stage, SimpleStageAction, RenderTargetsStageAction, RenderTargetStageAction, MeshStageAction, EvaluateSubMeshStageAction, ActiveMeshStageAction, CameraStageAction, RenderingGroupStageAction, RenderingMeshStageAction, PointerMoveStageAction, PointerUpDownStageAction } from "sceneComponent";
@@ -162,6 +164,9 @@ import { Constants } from "Engine/constants";
 
         // Members
 
+        /** @hidden */
+        public readonly _isScene = true;
+
         /**
          * Gets or sets a boolean that indicates if the scene must clear the render buffer before rendering a frame
          */
@@ -1687,24 +1692,24 @@ import { Constants } from "Engine/constants";
                 var actionManager = pickResult.pickedMesh.actionManager;
                 if (actionManager) {
                     if (actionManager.hasPickTriggers) {
-                        actionManager.processTrigger(ActionManager.OnPickDownTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
+                        actionManager.processTrigger(Constants.ACTION_OnPickDownTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                         switch (evt.button) {
                             case 0:
-                                actionManager.processTrigger(ActionManager.OnLeftPickTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
+                                actionManager.processTrigger(Constants.ACTION_OnLeftPickTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                                 break;
                             case 1:
-                                actionManager.processTrigger(ActionManager.OnCenterPickTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
+                                actionManager.processTrigger(Constants.ACTION_OnCenterPickTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                                 break;
                             case 2:
-                                actionManager.processTrigger(ActionManager.OnRightPickTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
+                                actionManager.processTrigger(Constants.ACTION_OnRightPickTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                                 break;
                         }
                     }
 
-                    if (actionManager.hasSpecificTrigger(ActionManager.OnLongPressTrigger)) {
+                    if (actionManager.hasSpecificTrigger(Constants.ACTION_OnLongPressTrigger)) {
                         window.setTimeout(() => {
                             var pickResult = this.pick(this._unTranslatedPointerX, this._unTranslatedPointerY,
-                                (mesh: AbstractMesh): boolean => (<boolean>(mesh.isPickable && mesh.isVisible && mesh.isReady() && mesh.actionManager && mesh.actionManager.hasSpecificTrigger(ActionManager.OnLongPressTrigger) && mesh == this._pickedDownMesh)),
+                                (mesh: AbstractMesh): boolean => (<boolean>(mesh.isPickable && mesh.isVisible && mesh.isReady() && mesh.actionManager && mesh.actionManager.hasSpecificTrigger(Constants.ACTION_OnLongPressTrigger) && mesh == this._pickedDownMesh)),
                                 false, this.cameraToUseForPointers);
 
                             if (pickResult && pickResult.hit && pickResult.pickedMesh && actionManager) {
@@ -1712,7 +1717,7 @@ import { Constants } from "Engine/constants";
                                     ((Date.now() - this._startingPointerTime) > Scene.LongPressDelay) &&
                                     !this._isPointerSwiping()) {
                                     this._startingPointerTime = 0;
-                                    actionManager.processTrigger(ActionManager.OnLongPressTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
+                                    actionManager.processTrigger(Constants.ACTION_OnLongPressTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                                 }
                             }
                         }, Scene.LongPressDelay);
@@ -1782,13 +1787,13 @@ import { Constants } from "Engine/constants";
                     }
                 }
                 if (pickResult.pickedMesh.actionManager && !clickInfo.ignore) {
-                    pickResult.pickedMesh.actionManager.processTrigger(ActionManager.OnPickUpTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
+                    pickResult.pickedMesh.actionManager.processTrigger(Constants.ACTION_OnPickUpTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
 
                     if (!clickInfo.hasSwiped && clickInfo.singleClick) {
-                        pickResult.pickedMesh.actionManager.processTrigger(ActionManager.OnPickTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
+                        pickResult.pickedMesh.actionManager.processTrigger(Constants.ACTION_OnPickTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                     }
-                    if (clickInfo.doubleClick && pickResult.pickedMesh.actionManager.hasSpecificTrigger(ActionManager.OnDoublePickTrigger)) {
-                        pickResult.pickedMesh.actionManager.processTrigger(ActionManager.OnDoublePickTrigger, 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));
                     }
                 }
             }
@@ -1802,9 +1807,9 @@ import { Constants } from "Engine/constants";
 
             if (this._pickedDownMesh &&
                 this._pickedDownMesh.actionManager &&
-                this._pickedDownMesh.actionManager.hasSpecificTrigger(ActionManager.OnPickOutTrigger) &&
+                this._pickedDownMesh.actionManager.hasSpecificTrigger(Constants.ACTION_OnPickOutTrigger) &&
                 this._pickedDownMesh !== this._pickedUpMesh) {
-                this._pickedDownMesh.actionManager.processTrigger(ActionManager.OnPickOutTrigger, ActionEvent.CreateNew(this._pickedDownMesh, evt));
+                this._pickedDownMesh.actionManager.processTrigger(Constants.ACTION_OnPickOutTrigger, ActionEvent.CreateNew(this._pickedDownMesh, evt));
             }
 
             let type = 0;
@@ -1892,7 +1897,7 @@ import { Constants } from "Engine/constants";
                 let checkPicking = obs1.hasSpecificMask(PointerEventTypes.POINTERPICK) || obs2.hasSpecificMask(PointerEventTypes.POINTERPICK)
                     || obs1.hasSpecificMask(PointerEventTypes.POINTERTAP) || obs2.hasSpecificMask(PointerEventTypes.POINTERTAP)
                     || obs1.hasSpecificMask(PointerEventTypes.POINTERDOUBLETAP) || obs2.hasSpecificMask(PointerEventTypes.POINTERDOUBLETAP);
-                if (!checkPicking && ActionManager && ActionManager.HasPickTriggers) {
+                if (!checkPicking && ActionManager) {
                     act = this._initActionManager(act, clickInfo);
                     if (act) {
                         checkPicking = act.hasPickTriggers;
@@ -1912,10 +1917,10 @@ import { Constants } from "Engine/constants";
                             checkSingleClickImmediately = !obs1.hasSpecificMask(PointerEventTypes.POINTERDOUBLETAP) &&
                                 !obs2.hasSpecificMask(PointerEventTypes.POINTERDOUBLETAP);
 
-                            if (checkSingleClickImmediately && !ActionManager.HasSpecificTrigger(ActionManager.OnDoublePickTrigger)) {
+                            if (checkSingleClickImmediately && !ActionManager.HasSpecificTrigger(Constants.ACTION_OnDoublePickTrigger)) {
                                 act = this._initActionManager(act, clickInfo);
                                 if (act) {
-                                    checkSingleClickImmediately = !act.hasSpecificTrigger(ActionManager.OnDoublePickTrigger);
+                                    checkSingleClickImmediately = !act.hasSpecificTrigger(Constants.ACTION_OnDoublePickTrigger);
                                 }
                             }
                         }
@@ -1938,10 +1943,10 @@ import { Constants } from "Engine/constants";
 
                         let checkDoubleClick = obs1.hasSpecificMask(PointerEventTypes.POINTERDOUBLETAP) ||
                             obs2.hasSpecificMask(PointerEventTypes.POINTERDOUBLETAP);
-                        if (!checkDoubleClick && ActionManager.HasSpecificTrigger(ActionManager.OnDoublePickTrigger)) {
+                        if (!checkDoubleClick && ActionManager.HasSpecificTrigger(Constants.ACTION_OnDoublePickTrigger)) {
                             act = this._initActionManager(act, clickInfo);
                             if (act) {
-                                checkDoubleClick = act.hasSpecificTrigger(ActionManager.OnDoublePickTrigger);
+                                checkDoubleClick = act.hasSpecificTrigger(Constants.ACTION_OnDoublePickTrigger);
                             }
                         }
                         if (checkDoubleClick) {
@@ -2144,7 +2149,7 @@ import { Constants } from "Engine/constants";
                 }
 
                 if (this.actionManager) {
-                    this.actionManager.processTrigger(ActionManager.OnKeyDownTrigger, ActionEvent.CreateNewFromScene(this, evt));
+                    this.actionManager.processTrigger(Constants.ACTION_OnKeyDownTrigger, ActionEvent.CreateNewFromScene(this, evt));
                 }
             };
 
@@ -2164,7 +2169,7 @@ import { Constants } from "Engine/constants";
                 }
 
                 if (this.actionManager) {
-                    this.actionManager.processTrigger(ActionManager.OnKeyUpTrigger, ActionEvent.CreateNewFromScene(this, evt));
+                    this.actionManager.processTrigger(Constants.ACTION_OnKeyUpTrigger, ActionEvent.CreateNewFromScene(this, evt));
                 }
             };
 
@@ -4304,7 +4309,7 @@ import { Constants } from "Engine/constants";
                 mesh.computeWorldMatrix();
 
                 // Intersections
-                if (mesh.actionManager && mesh.actionManager.hasSpecificTriggers2(ActionManager.OnIntersectionEnterTrigger, ActionManager.OnIntersectionExitTrigger)) {
+                if (mesh.actionManager && mesh.actionManager.hasSpecificTriggers2(Constants.ACTION_OnIntersectionEnterTrigger, Constants.ACTION_OnIntersectionExitTrigger)) {
                     this._meshesForIntersections.pushNoDuplicate(mesh);
                 }
 
@@ -4551,7 +4556,7 @@ import { Constants } from "Engine/constants";
                 for (var actionIndex = 0; actionIndex < sourceMesh.actionManager.actions.length; actionIndex++) {
                     var action = sourceMesh.actionManager.actions[actionIndex];
 
-                    if (action.trigger === ActionManager.OnIntersectionEnterTrigger || action.trigger === ActionManager.OnIntersectionExitTrigger) {
+                    if (action.trigger === Constants.ACTION_OnIntersectionEnterTrigger || action.trigger === Constants.ACTION_OnIntersectionExitTrigger) {
                         var parameters = action.getTriggerParameter();
                         var otherMesh = parameters instanceof AbstractMesh ? parameters : parameters.mesh;
 
@@ -4559,25 +4564,25 @@ import { Constants } from "Engine/constants";
                         var currentIntersectionInProgress = sourceMesh._intersectionsInProgress.indexOf(otherMesh);
 
                         if (areIntersecting && currentIntersectionInProgress === -1) {
-                            if (action.trigger === ActionManager.OnIntersectionEnterTrigger) {
+                            if (action.trigger === Constants.ACTION_OnIntersectionEnterTrigger) {
                                 action._executeCurrent(ActionEvent.CreateNew(sourceMesh, undefined, otherMesh));
                                 sourceMesh._intersectionsInProgress.push(otherMesh);
-                            } else if (action.trigger === ActionManager.OnIntersectionExitTrigger) {
+                            } else if (action.trigger === Constants.ACTION_OnIntersectionExitTrigger) {
                                 sourceMesh._intersectionsInProgress.push(otherMesh);
                             }
                         } else if (!areIntersecting && currentIntersectionInProgress > -1) {
                             //They intersected, and now they don't.
 
                             //is this trigger an exit trigger? execute an event.
-                            if (action.trigger === ActionManager.OnIntersectionExitTrigger) {
+                            if (action.trigger === Constants.ACTION_OnIntersectionExitTrigger) {
                                 action._executeCurrent(ActionEvent.CreateNew(sourceMesh, undefined, otherMesh));
                             }
 
                             //if this is an exit trigger, or no exit trigger exists, remove the id from the intersection in progress array.
-                            if (!sourceMesh.actionManager.hasSpecificTrigger(ActionManager.OnIntersectionExitTrigger, (parameter) => {
+                            if (!sourceMesh.actionManager.hasSpecificTrigger(Constants.ACTION_OnIntersectionExitTrigger, (parameter) => {
                                 var parameterMesh = parameter instanceof AbstractMesh ? parameter : parameter.mesh;
                                 return otherMesh === parameterMesh;
-                            }) || action.trigger === ActionManager.OnIntersectionExitTrigger) {
+                            }) || action.trigger === Constants.ACTION_OnIntersectionExitTrigger) {
                                 sourceMesh._intersectionsInProgress.splice(currentIntersectionInProgress, 1);
                             }
                         }
@@ -4623,7 +4628,7 @@ import { Constants } from "Engine/constants";
 
             // Actions
             if (this.actionManager) {
-                this.actionManager.processTrigger(ActionManager.OnEveryFrameTrigger);
+                this.actionManager.processTrigger(Constants.ACTION_OnEveryFrameTrigger);
             }
 
             if (this._engine.isDeterministicLockStep()) {
@@ -5364,12 +5369,12 @@ import { Constants } from "Engine/constants";
             }
 
             if (this._pointerOverMesh && this._pointerOverMesh.actionManager) {
-                this._pointerOverMesh.actionManager.processTrigger(ActionManager.OnPointerOutTrigger, ActionEvent.CreateNew(this._pointerOverMesh));
+                this._pointerOverMesh.actionManager.processTrigger(Constants.ACTION_OnPointerOutTrigger, ActionEvent.CreateNew(this._pointerOverMesh));
             }
 
             this._pointerOverMesh = mesh;
             if (this._pointerOverMesh && this._pointerOverMesh.actionManager) {
-                this._pointerOverMesh.actionManager.processTrigger(ActionManager.OnPointerOverTrigger, ActionEvent.CreateNew(this._pointerOverMesh));
+                this._pointerOverMesh.actionManager.processTrigger(Constants.ACTION_OnPointerOverTrigger, ActionEvent.CreateNew(this._pointerOverMesh));
             }
         }