@babylonjs/gui 5.0.0-alpha.60 → 5.0.0-alpha.64

package/2D/advancedDynamicTexture.js

@@ -2,7 +2,7 @@ import { __extends } from "tslib";
 import { Observable } from "@babylonjs/core/Misc/observable.js";
 import { Vector2, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
 import { Tools } from "@babylonjs/core/Misc/tools.js";
-import { PointerEventTypes } from '@babylonjs/core/Events/pointerEvents.js';
+import { PointerEventTypes } from "@babylonjs/core/Events/pointerEvents.js";
 import { ClipboardEventTypes, ClipboardInfo } from "@babylonjs/core/Events/clipboardEvents.js";
 import { KeyboardEventTypes } from "@babylonjs/core/Events/keyboardEvents.js";
 import { StandardMaterial } from "@babylonjs/core/Materials/standardMaterial.js";
@@ -13,26 +13,26 @@ import { Container } from "./controls/container.js";
 import { Control } from "./controls/control.js";
 import { Style } from "./style.js";
 import { Measure } from "./measure.js";
-import { Constants } from '@babylonjs/core/Engines/constants.js';
-import { Viewport } from '@babylonjs/core/Maths/math.viewport.js';
-import { Color3 } from '@babylonjs/core/Maths/math.color.js';
+import { Constants } from "@babylonjs/core/Engines/constants.js";
+import { Viewport } from "@babylonjs/core/Maths/math.viewport.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
 import { WebRequest } from "@babylonjs/core/Misc/webRequest.js";
 /**
-* Class used to create texture to support 2D GUI elements
-* @see https://doc.babylonjs.com/how_to/gui
-*/
+ * Class used to create texture to support 2D GUI elements
+ * @see https://doc.babylonjs.com/how_to/gui
+ */
 var AdvancedDynamicTexture = /** @class */ (function (_super) {
     __extends(AdvancedDynamicTexture, _super);
     /**
-   * Creates a new AdvancedDynamicTexture
-   * @param name defines the name of the texture
-   * @param width defines the width of the texture
-   * @param height defines the height of the texture
-   * @param scene defines the hosting scene
-   * @param generateMipMaps defines a boolean indicating if mipmaps must be generated (false by default)
-   * @param samplingMode defines the texture sampling mode (Texture.NEAREST_SAMPLINGMODE by default)
-   * @param invertY defines if the texture needs to be inverted on the y axis during loading (true by default)
-   */
+     * Creates a new AdvancedDynamicTexture
+     * @param name defines the name of the texture
+     * @param width defines the width of the texture
+     * @param height defines the height of the texture
+     * @param scene defines the hosting scene
+     * @param generateMipMaps defines a boolean indicating if mipmaps must be generated (false by default)
+     * @param samplingMode defines the texture sampling mode (Texture.NEAREST_SAMPLINGMODE by default)
+     * @param invertY defines if the texture needs to be inverted on the y axis during loading (true by default)
+     */
     function AdvancedDynamicTexture(name, width, height, scene, generateMipMaps, samplingMode, invertY) {
         if (width === void 0) { width = 0; }
         if (height === void 0) { height = 0; }
@@ -66,37 +66,37 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
         /** @hidden */
         _this._numRenderCalls = 0;
         /**
-        * Define type to string to ensure compatibility across browsers
-        * Safari doesn't support DataTransfer constructor
-        */
+         * Define type to string to ensure compatibility across browsers
+         * Safari doesn't support DataTransfer constructor
+         */
         _this._clipboardData = "";
         /**
-        * Observable event triggered each time an clipboard event is received from the rendering canvas
-        */
+         * Observable event triggered each time an clipboard event is received from the rendering canvas
+         */
         _this.onClipboardObservable = new Observable();
         /**
-        * Observable event triggered each time a pointer down is intercepted by a control
-        */
+         * Observable event triggered each time a pointer down is intercepted by a control
+         */
         _this.onControlPickedObservable = new Observable();
         /**
-        * Observable event triggered before layout is evaluated
-        */
+         * Observable event triggered before layout is evaluated
+         */
         _this.onBeginLayoutObservable = new Observable();
         /**
-        * Observable event triggered after the layout was evaluated
-        */
+         * Observable event triggered after the layout was evaluated
+         */
         _this.onEndLayoutObservable = new Observable();
         /**
-        * Observable event triggered before the texture is rendered
-        */
+         * Observable event triggered before the texture is rendered
+         */
         _this.onBeginRenderObservable = new Observable();
         /**
-        * Observable event triggered after the texture was rendered
-        */
+         * Observable event triggered after the texture was rendered
+         */
         _this.onEndRenderObservable = new Observable();
         /**
-        * Gets or sets a boolean defining if alpha is stored as premultiplied
-        */
+         * Gets or sets a boolean defining if alpha is stored as premultiplied
+         */
         _this.premulAlpha = false;
         /**
          * Gets or sets a boolean indicating that the canvas must be reverted on Y when updating the texture
@@ -170,9 +170,9 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
     });
     Object.defineProperty(AdvancedDynamicTexture.prototype, "renderScale", {
         /**
-        * Gets or sets a number used to scale rendering size (2 means that the texture will be twice bigger).
-        * Useful when you want more antialiasing
-        */
+         * Gets or sets a number used to scale rendering size (2 means that the texture will be twice bigger).
+         * Useful when you want more antialiasing
+         */
         get: function () {
             return this._renderScale;
         },
@@ -203,10 +203,10 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
     });
     Object.defineProperty(AdvancedDynamicTexture.prototype, "idealWidth", {
         /**
-        * Gets or sets the ideal width used to design controls.
-        * The GUI will then rescale everything accordingly
-        * @see https://doc.babylonjs.com/how_to/gui#adaptive-scaling
-        */
+         * Gets or sets the ideal width used to design controls.
+         * The GUI will then rescale everything accordingly
+         * @see https://doc.babylonjs.com/how_to/gui#adaptive-scaling
+         */
         get: function () {
             return this._idealWidth;
         },
@@ -223,10 +223,10 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
     });
     Object.defineProperty(AdvancedDynamicTexture.prototype, "idealHeight", {
         /**
-        * Gets or sets the ideal height used to design controls.
-        * The GUI will then rescale everything accordingly
-        * @see https://doc.babylonjs.com/how_to/gui#adaptive-scaling
-        */
+         * Gets or sets the ideal height used to design controls.
+         * The GUI will then rescale everything accordingly
+         * @see https://doc.babylonjs.com/how_to/gui#adaptive-scaling
+         */
         get: function () {
             return this._idealHeight;
         },
@@ -243,9 +243,9 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
     });
     Object.defineProperty(AdvancedDynamicTexture.prototype, "useSmallestIdeal", {
         /**
-        * Gets or sets a boolean indicating if the smallest ideal value must be used if idealWidth and idealHeight are both set
-        * @see https://doc.babylonjs.com/how_to/gui#adaptive-scaling
-        */
+         * Gets or sets a boolean indicating if the smallest ideal value must be used if idealWidth and idealHeight are both set
+         * @see https://doc.babylonjs.com/how_to/gui#adaptive-scaling
+         */
         get: function () {
             return this._useSmallestIdeal;
         },
@@ -262,9 +262,9 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
     });
     Object.defineProperty(AdvancedDynamicTexture.prototype, "renderAtIdealSize", {
         /**
-        * Gets or sets a boolean indicating if adaptive scaling must be used
-        * @see https://doc.babylonjs.com/how_to/gui#adaptive-scaling
-        */
+         * Gets or sets a boolean indicating if adaptive scaling must be used
+         * @see https://doc.babylonjs.com/how_to/gui#adaptive-scaling
+         */
         get: function () {
             return this._renderAtIdealSize;
         },
@@ -281,24 +281,26 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
     Object.defineProperty(AdvancedDynamicTexture.prototype, "idealRatio", {
         /**
          * Gets the ratio used when in "ideal mode"
-        * @see https://doc.babylonjs.com/how_to/gui#adaptive-scaling
+         * @see https://doc.babylonjs.com/how_to/gui#adaptive-scaling
          * */
         get: function () {
             var rwidth = 0;
             var rheight = 0;
             if (this._idealWidth) {
-                rwidth = (this.getSize().width) / this._idealWidth;
+                rwidth = this.getSize().width / this._idealWidth;
             }
             if (this._idealHeight) {
-                rheight = (this.getSize().height) / this._idealHeight;
+                rheight = this.getSize().height / this._idealHeight;
             }
             if (this._useSmallestIdeal && this._idealWidth && this._idealHeight) {
                 return window.innerWidth < window.innerHeight ? rwidth : rheight;
             }
-            if (this._idealWidth) { // horizontal
+            if (this._idealWidth) {
+                // horizontal
                 return rwidth;
             }
-            if (this._idealHeight) { // vertical
+            if (this._idealHeight) {
+                // vertical
                 return rheight;
             }
             return 1;
@@ -308,8 +310,8 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
     });
     Object.defineProperty(AdvancedDynamicTexture.prototype, "layer", {
         /**
-        * Gets the underlying layer used to render the texture when in fullscreen mode
-        */
+         * Gets the underlying layer used to render the texture when in fullscreen mode
+         */
         get: function () {
             return this._layerToDispose;
         },
@@ -318,8 +320,8 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
     });
     Object.defineProperty(AdvancedDynamicTexture.prototype, "rootContainer", {
         /**
-        * Gets the root container control
-        */
+         * Gets the root container control
+         */
         get: function () {
             return this._rootContainer;
         },
@@ -327,35 +329,35 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
         configurable: true
     });
     /**
-    * Returns an array containing the root container.
-    * This is mostly used to let the Inspector introspects the ADT
-    * @returns an array containing the rootContainer
-    */
+     * Returns an array containing the root container.
+     * This is mostly used to let the Inspector introspects the ADT
+     * @returns an array containing the rootContainer
+     */
     AdvancedDynamicTexture.prototype.getChildren = function () {
         return [this._rootContainer];
     };
     /**
-    * Will return all controls that are inside this texture
-    * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
-    * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
-    * @return all child controls
-    */
+     * Will return all controls that are inside this texture
+     * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered
+     * @param predicate defines an optional predicate that will be called on every evaluated child, the predicate must return true for a given child to be part of the result, otherwise it will be ignored
+     * @return all child controls
+     */
     AdvancedDynamicTexture.prototype.getDescendants = function (directDescendantsOnly, predicate) {
         return this._rootContainer.getDescendants(directDescendantsOnly, predicate);
     };
     /**
-    * Will return all controls with the given type name
-    * @param typeName defines the type name to search for
-    * @returns an array of all controls found
-    */
+     * Will return all controls with the given type name
+     * @param typeName defines the type name to search for
+     * @returns an array of all controls found
+     */
     AdvancedDynamicTexture.prototype.getControlsByType = function (typeName) {
         return this._rootContainer.getDescendants(false, function (control) { return control.typeName === typeName; });
     };
     /**
-    * Will return the first control with the given name
-    * @param name defines the name to search for
-    * @return the first control found or null
-    */
+     * Will return the first control with the given name
+     * @param name defines the name to search for
+     * @return the first control found or null
+     */
     AdvancedDynamicTexture.prototype.getControlByName = function (name) {
         return this._getControlByKey("name", name);
     };
@@ -364,8 +366,8 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
     };
     Object.defineProperty(AdvancedDynamicTexture.prototype, "focusedControl", {
         /**
-        * Gets or sets the current focused control
-        */
+         * Gets or sets the current focused control
+         */
         get: function () {
             return this._focusedControl;
         },
@@ -386,13 +388,13 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
     });
     Object.defineProperty(AdvancedDynamicTexture.prototype, "isForeground", {
         /**
-        * Gets or sets a boolean indicating if the texture must be rendered in background or foreground when in fullscreen mode
-        */
+         * Gets or sets a boolean indicating if the texture must be rendered in background or foreground when in fullscreen mode
+         */
         get: function () {
             if (!this.layer) {
                 return true;
             }
-            return (!this.layer.isBackground);
+            return !this.layer.isBackground;
         },
         set: function (value) {
             if (!this.layer) {
@@ -408,8 +410,8 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
     });
     Object.defineProperty(AdvancedDynamicTexture.prototype, "clipboardData", {
         /**
-        * Gets or set information about clipboardData
-        */
+         * Gets or set information about clipboardData
+         */
         get: function () {
             return this._clipboardData;
         },
@@ -420,17 +422,17 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
         configurable: true
     });
     /**
-    * Get the current class name of the texture useful for serialization or dynamic coding.
-    * @returns "AdvancedDynamicTexture"
-    */
+     * Get the current class name of the texture useful for serialization or dynamic coding.
+     * @returns "AdvancedDynamicTexture"
+     */
     AdvancedDynamicTexture.prototype.getClassName = function () {
         return "AdvancedDynamicTexture";
     };
     /**
-    * Function used to execute a function on all controls
-    * @param func defines the function to execute
-    * @param container defines the container where controls belong. If null the root container will be used
-    */
+     * Function used to execute a function on all controls
+     * @param func defines the function to execute
+     * @param container defines the container where controls belong. If null the root container will be used
+     */
     AdvancedDynamicTexture.prototype.executeOnAllControls = function (func, container) {
         if (!container) {
             container = this._rootContainer;
@@ -483,40 +485,83 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
         }
     };
     /**
-    * Marks the texture as dirty forcing a complete update
-    */
+     * Marks the texture as dirty forcing a complete update
+     */
     AdvancedDynamicTexture.prototype.markAsDirty = function () {
         this._isDirty = true;
     };
     /**
-    * Helper function used to create a new style
-    * @returns a new style
-    * @see https://doc.babylonjs.com/how_to/gui#styles
-    */
+     * Helper function used to create a new style
+     * @returns a new style
+     * @see https://doc.babylonjs.com/how_to/gui#styles
+     */
     AdvancedDynamicTexture.prototype.createStyle = function () {
         return new Style(this);
     };
     /**
-    * Adds a new control to the root container
-    * @param control defines the control to add
-    * @returns the current texture
-    */
+     * Adds a new control to the root container
+     * @param control defines the control to add
+     * @returns the current texture
+     */
     AdvancedDynamicTexture.prototype.addControl = function (control) {
         this._rootContainer.addControl(control);
         return this;
     };
     /**
-    * Removes a control from the root container
-    * @param control defines the control to remove
-    * @returns the current texture
-    */
+     * Removes a control from the root container
+     * @param control defines the control to remove
+     * @returns the current texture
+     */
     AdvancedDynamicTexture.prototype.removeControl = function (control) {
         this._rootContainer.removeControl(control);
         return this;
     };
     /**
-    * Release all resources
-    */
+     * Moves overlapped controls towards a position where it is not overlapping anymore.
+     * Please note that this method alters linkOffsetXInPixels and linkOffsetYInPixels.
+     * @param overlapGroup the overlap group which will be processed or undefined to process all overlap groups
+     * @param deltaStep the step size (speed) to reach the target non overlapping position (default 0.1)
+     * @param repelFactor how much is the control repelled by other controls
+     */
+    AdvancedDynamicTexture.prototype.moveToNonOverlappedPosition = function (overlapGroup, deltaStep, repelFactor) {
+        if (deltaStep === void 0) { deltaStep = 1; }
+        if (repelFactor === void 0) { repelFactor = 1; }
+        var controlsForGroup;
+        if (Array.isArray(overlapGroup)) {
+            controlsForGroup = overlapGroup;
+        }
+        else {
+            var descendants = this.getDescendants(true);
+            // get only the controls with an overlapGroup property set
+            // if the overlapGroup parameter is set, filter the controls and get only the controls belonging to that overlapGroup
+            controlsForGroup = overlapGroup === undefined ? descendants.filter(function (c) { return c.overlapGroup !== undefined; }) : descendants.filter(function (c) { return c.overlapGroup === overlapGroup; });
+        }
+        controlsForGroup.forEach(function (control1) {
+            var _a;
+            var velocity = Vector2.Zero();
+            var center = new Vector2(control1.centerX, control1.centerY);
+            controlsForGroup.forEach(function (control2) {
+                if (control1 !== control2 && AdvancedDynamicTexture._Overlaps(control1, control2)) {
+                    // if the two controls overlaps get a direction vector from one control's center to another control's center
+                    var diff = center.subtract(new Vector2(control2.centerX, control2.centerY));
+                    var diffLength = diff.length();
+                    if (diffLength > 0) {
+                        // calculate the velocity
+                        velocity = velocity.add(diff.normalize().scale(repelFactor / diffLength));
+                    }
+                }
+            });
+            if (velocity.length() > 0) {
+                // move the control along the direction vector away from the overlapping control
+                velocity = velocity.normalize().scale(deltaStep * ((_a = control1.overlapDeltaMultiplier) !== null && _a !== void 0 ? _a : 1));
+                control1.linkOffsetXInPixels += velocity.x;
+                control1.linkOffsetYInPixels += velocity.y;
+            }
+        });
+    };
+    /**
+     * Release all resources
+     */
     AdvancedDynamicTexture.prototype.dispose = function () {
         var scene = this.getScene();
         if (!scene) {
@@ -588,24 +633,31 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
     /** @hidden */
     AdvancedDynamicTexture.prototype._getGlobalViewport = function () {
         var size = this.getSize();
-        return this._fullscreenViewport.toGlobal(size.width, size.height);
+        var globalViewPort = this._fullscreenViewport.toGlobal(size.width, size.height);
+        var targetX = Math.round(globalViewPort.width * (1 / this.rootContainer.scaleX));
+        var targetY = Math.round(globalViewPort.height * (1 / this.rootContainer.scaleY));
+        globalViewPort.x += (globalViewPort.width - targetX) / 2;
+        globalViewPort.y += (globalViewPort.height - targetY) / 2;
+        globalViewPort.width = targetX;
+        globalViewPort.height = targetY;
+        return globalViewPort;
     };
     /**
-    * Get screen coordinates for a vector3
-    * @param position defines the position to project
-    * @param worldMatrix defines the world matrix to use
-    * @returns the projected position
-    */
+     * Get screen coordinates for a vector3
+     * @param position defines the position to project
+     * @param worldMatrix defines the world matrix to use
+     * @returns the projected position
+     */
     AdvancedDynamicTexture.prototype.getProjectedPosition = function (position, worldMatrix) {
         var result = this.getProjectedPositionWithZ(position, worldMatrix);
         return new Vector2(result.x, result.y);
     };
     /**
-    * Get screen coordinates for a vector3
-    * @param position defines the position to project
-    * @param worldMatrix defines the world matrix to use
-    * @returns the projected position with Z
-    */
+     * Get screen coordinates for a vector3
+     * @param position defines the position to project
+     * @param worldMatrix defines the world matrix to use
+     * @returns the projected position with Z
+     */
     AdvancedDynamicTexture.prototype.getProjectedPositionWithZ = function (position, worldMatrix) {
         var scene = this.getScene();
         if (!scene) {
@@ -657,7 +709,7 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
         }
         this._isDirty = false;
         this._render();
-        this.update(this.applyYInversionOnUpdate, this.premulAlpha);
+        this.update(this.applyYInversionOnUpdate, this.premulAlpha, AdvancedDynamicTexture.AllowGPUOptimizations);
     };
     AdvancedDynamicTexture.prototype._render = function () {
         var textureSize = this.getSize();
@@ -769,13 +821,13 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
         }
         var tempViewport = new Viewport(0, 0, 0, 0);
         this._pointerMoveObserver = scene.onPrePointerObservable.add(function (pi, state) {
-            if (scene.isPointerCaptured((pi.event).pointerId)) {
+            if (scene.isPointerCaptured(pi.event.pointerId)) {
                 return;
             }
-            if (pi.type !== PointerEventTypes.POINTERMOVE
-                && pi.type !== PointerEventTypes.POINTERUP
-                && pi.type !== PointerEventTypes.POINTERDOWN
-                && pi.type !== PointerEventTypes.POINTERWHEEL) {
+            if (pi.type !== PointerEventTypes.POINTERMOVE &&
+                pi.type !== PointerEventTypes.POINTERUP &&
+                pi.type !== PointerEventTypes.POINTERDOWN &&
+                pi.type !== PointerEventTypes.POINTERWHEEL) {
                 return;
             }
             if (pi.type === PointerEventTypes.POINTERMOVE && pi.event.pointerId) {
@@ -783,6 +835,7 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
             }
             var camera = scene.cameraToUseForPointers || scene.activeCamera;
             var engine = scene.getEngine();
+            var originalCameraToUseForPointers = scene.cameraToUseForPointers;
             if (!camera) {
                 tempViewport.x = 0;
                 tempViewport.y = 0;
@@ -790,7 +843,31 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
                 tempViewport.height = engine.getRenderHeight();
             }
             else {
-                camera.viewport.toGlobalToRef(engine.getRenderWidth(), engine.getRenderHeight(), tempViewport);
+                if (camera.rigCameras.length) {
+                    // rig camera - we need to find the camera to use for this event
+                    var rigViewport_1 = new Viewport(0, 0, 1, 1);
+                    camera.rigCameras.forEach(function (rigCamera) {
+                        // generate the viewport of this camera
+                        rigCamera.viewport.toGlobalToRef(engine.getRenderWidth(), engine.getRenderHeight(), rigViewport_1);
+                        var x = scene.pointerX / engine.getHardwareScalingLevel() - rigViewport_1.x;
+                        var y = scene.pointerY / engine.getHardwareScalingLevel() - (engine.getRenderHeight() - rigViewport_1.y - rigViewport_1.height);
+                        // check if the pointer is in the camera's viewport
+                        if (x < 0 || y < 0 || x > rigViewport_1.width || y > rigViewport_1.height) {
+                            // out of viewport - don't use this camera
+                            return;
+                        }
+                        // set the camera to use for pointers until this pointer loop is over
+                        scene.cameraToUseForPointers = rigCamera;
+                        // set the viewport
+                        tempViewport.x = rigViewport_1.x;
+                        tempViewport.y = rigViewport_1.y;
+                        tempViewport.width = rigViewport_1.width;
+                        tempViewport.height = rigViewport_1.height;
+                    });
+                }
+                else {
+                    camera.viewport.toGlobalToRef(engine.getRenderWidth(), engine.getRenderHeight(), tempViewport);
+                }
             }
             var x = scene.pointerX / engine.getHardwareScalingLevel() - tempViewport.x;
             var y = scene.pointerY / engine.getHardwareScalingLevel() - (engine.getRenderHeight() - tempViewport.y - tempViewport.height);
@@ -802,13 +879,15 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
             if (_this._shouldBlockPointer) {
                 pi.skipOnPointerObservable = _this._shouldBlockPointer;
             }
+            // if overridden by a rig camera - reset back to the original value
+            scene.cameraToUseForPointers = originalCameraToUseForPointers;
         });
         this._attachToOnPointerOut(scene);
         this._attachToOnBlur(scene);
     };
     /**
-    * Register the clipboard Events onto the canvas
-    */
+     * Register the clipboard Events onto the canvas
+     */
     AdvancedDynamicTexture.prototype.registerClipboardEvents = function () {
         self.addEventListener("copy", this.onClipboardCopy, false);
         self.addEventListener("cut", this.onClipboardCut, false);
@@ -823,10 +902,10 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
         self.removeEventListener("paste", this.onClipboardPaste);
     };
     /**
-    * Connect the texture to a hosting mesh to enable interactions
-    * @param mesh defines the mesh to attach to
-    * @param supportPointerMove defines a boolean indicating if pointer move events must be catched as well
-    */
+     * Connect the texture to a hosting mesh to enable interactions
+     * @param mesh defines the mesh to attach to
+     * @param supportPointerMove defines a boolean indicating if pointer move events must be catched as well
+     */
     AdvancedDynamicTexture.prototype.attachToMesh = function (mesh, supportPointerMove) {
         var _this = this;
         if (supportPointerMove === void 0) { supportPointerMove = true; }
@@ -835,10 +914,10 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
             return;
         }
         this._pointerObserver = scene.onPointerObservable.add(function (pi, state) {
-            if (pi.type !== PointerEventTypes.POINTERMOVE
-                && pi.type !== PointerEventTypes.POINTERUP
-                && pi.type !== PointerEventTypes.POINTERDOWN
-                && pi.type !== PointerEventTypes.POINTERWHEEL) {
+            if (pi.type !== PointerEventTypes.POINTERMOVE &&
+                pi.type !== PointerEventTypes.POINTERUP &&
+                pi.type !== PointerEventTypes.POINTERDOWN &&
+                pi.type !== PointerEventTypes.POINTERWHEEL) {
                 return;
             }
             if (pi.type === PointerEventTypes.POINTERMOVE && pi.event.pointerId) {
@@ -849,7 +928,7 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
                 var uv = pi.pickInfo.getTextureCoordinates();
                 if (uv) {
                     var size = _this.getSize();
-                    _this._doPicking(uv.x * size.width, (_this.applyYInversionOnUpdate ? (1.0 - uv.y) : uv.y) * size.height, pi, pi.type, pointerId, pi.event.button, pi.event.deltaX, pi.event.deltaY);
+                    _this._doPicking(uv.x * size.width, (_this.applyYInversionOnUpdate ? 1.0 - uv.y : uv.y) * size.height, pi, pi.type, pointerId, pi.event.button, pi.event.deltaX, pi.event.deltaY);
                 }
             }
             else if (pi.type === PointerEventTypes.POINTERUP) {
@@ -892,9 +971,9 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
         this._attachToOnBlur(scene);
     };
     /**
-    * Move the focus to a specific control
-    * @param control defines the control which will receive the focus
-    */
+     * Move the focus to a specific control
+     * @param control defines the control which will receive the focus
+     */
     AdvancedDynamicTexture.prototype.moveFocusToControl = function (control) {
         this.focusedControl = control;
         this._lastPickedControl = control;
@@ -964,7 +1043,7 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
         if (scaleToSize) {
             var width = serializedObject.width;
             var height = serializedObject.height;
-            if (typeof (width) === "number" && typeof (height) === "number" && width >= 0 && height >= 0) {
+            if (typeof width === "number" && typeof height === "number" && width >= 0 && height >= 0) {
                 this.scaleTo(width, height);
             }
         }
@@ -1001,11 +1080,11 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
         });
     };
     /**
-    * Recreate the content of the ADT from a url json
-    * @param url defines the url to load
-    * @param scaleToSize defines whether to scale to texture to the saved size
-    * @returns a promise that will resolve on success
-    */
+     * Recreate the content of the ADT from a url json
+     * @param url defines the url to load
+     * @param scaleToSize defines whether to scale to texture to the saved size
+     * @returns a promise that will resolve on success
+     */
     AdvancedDynamicTexture.prototype.parseFromURLAsync = function (url, scaleToSize) {
         var _this = this;
         if (url === "") {
@@ -1031,6 +1110,18 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
         });
     };
     // Statics
+    /**
+     * Compares two rectangle based controls for pixel overlap
+     * @param control1 The first control to compare
+     * @param control2 The second control to compare
+     * @returns true if overlaps, otherwise false
+     */
+    AdvancedDynamicTexture._Overlaps = function (control1, control2) {
+        return !(control1.centerX > control2.centerX + control2.widthInPixels ||
+            control1.centerX + control1.widthInPixels < control2.centerX ||
+            control1.centerY + control1.heightInPixels < control2.centerY ||
+            control1.centerY > control2.centerY + control2.heightInPixels);
+    };
     /**
      * Creates a new AdvancedDynamicTexture in projected mode (ie. attached to a mesh)
      * @param mesh defines the mesh which will receive the texture
@@ -1082,33 +1173,43 @@ var AdvancedDynamicTexture = /** @class */ (function (_super) {
         return result;
     };
     /**
-    * Creates a new AdvancedDynamicTexture in fullscreen mode.
-    * In this mode the texture will rely on a layer for its rendering.
-    * This allows it to be treated like any other layer.
-    * As such, if you have a multi camera setup, you can set the layerMask on the GUI as well.
-    * LayerMask is set through advancedTexture.layer.layerMask
-    * @param name defines name for the texture
-    * @param foreground defines a boolean indicating if the texture must be rendered in foreground (default is true)
-    * @param scene defines the hosting scene
-    * @param sampling defines the texture sampling mode (Texture.BILINEAR_SAMPLINGMODE by default)
-    * @returns a new AdvancedDynamicTexture
-    */
-    AdvancedDynamicTexture.CreateFullscreenUI = function (name, foreground, scene, sampling) {
+     * Creates a new AdvancedDynamicTexture in fullscreen mode.
+     * In this mode the texture will rely on a layer for its rendering.
+     * This allows it to be treated like any other layer.
+     * As such, if you have a multi camera setup, you can set the layerMask on the GUI as well.
+     * LayerMask is set through advancedTexture.layer.layerMask
+     * @param name defines name for the texture
+     * @param foreground defines a boolean indicating if the texture must be rendered in foreground (default is true)
+     * @param scene defines the hosting scene
+     * @param sampling defines the texture sampling mode (Texture.BILINEAR_SAMPLINGMODE by default)
+     * @param adaptiveScaling defines whether to automatically scale root to match hardwarescaling (false by default)
+     * @returns a new AdvancedDynamicTexture
+     */
+    AdvancedDynamicTexture.CreateFullscreenUI = function (name, foreground, scene, sampling, adaptiveScaling) {
         if (foreground === void 0) { foreground = true; }
         if (scene === void 0) { scene = null; }
         if (sampling === void 0) { sampling = Texture.BILINEAR_SAMPLINGMODE; }
+        if (adaptiveScaling === void 0) { adaptiveScaling = false; }
         var result = new AdvancedDynamicTexture(name, 0, 0, scene, false, sampling);
         // Display
-        var layer = new Layer(name + "_layer", null, scene, !foreground);
+        var resultScene = result.getScene();
+        var layer = new Layer(name + "_layer", null, resultScene, !foreground);
         layer.texture = result;
         result._layerToDispose = layer;
         result._isFullscreen = true;
+        if (adaptiveScaling && resultScene) {
+            var newScale = 1 / resultScene.getEngine().getHardwareScalingLevel();
+            result._rootContainer.scaleX = newScale;
+            result._rootContainer.scaleY = newScale;
+        }
         // Attach
         result.attach();
         return result;
     };
     /** Define the Uurl to load snippets */
     AdvancedDynamicTexture.SnippetUrl = "https://snippet.babylonjs.com";
+    /** Indicates if some optimizations can be performed in GUI GPU management (the downside is additional memory/GPU texture memory used) */
+    AdvancedDynamicTexture.AllowGPUOptimizations = true;
     return AdvancedDynamicTexture;
 }(DynamicTexture));
 export { AdvancedDynamicTexture };