babylonjs-gui 7.32.0 → 7.32.3

package/babylon.gui.d.ts

@@ -3852,6 +3852,18 @@ declare module BABYLON.GUI {
 
 
 
+    /**
+     * Interface used to define options to create an AdvancedDynamicTexture
+     */
+    export interface IAdvancedDynamicTextureOptions extends BABYLON.IDynamicTextureOptions {
+        /**
+         * Indicates whether the ADT will be used autonomously. In this mode:
+         * - _checkUpdate() is not called
+         * - the layer is not rendered (so, the ADT is not visible)
+         * It's up to the user to perform the required calls manually to update the ADT.
+         */
+        useStandalone?: boolean;
+    }
     /**
      * Class used to create texture to support 2D GUI elements
      * @see https://doc.babylonjs.com/features/featuresDeepDive/gui/gui
@@ -3861,6 +3873,8 @@ declare module BABYLON.GUI {
         static SnippetUrl: string;
         /** Indicates if some optimizations can be performed in GUI GPU management (the downside is additional memory/GPU texture memory used) */
         static AllowGPUOptimizations: boolean;
+        /** Indicates whether the ADT is used autonomously */
+        readonly useStandalone: boolean;
         /** Snippet ID if the content was created from the snippet server */
         snippetId: string;
         /** BABYLON.Observable that fires when the GUI is ready */
@@ -3965,6 +3979,10 @@ declare module BABYLON.GUI {
          * Defaults to false.
          */
         disableTabNavigation: boolean;
+        /**
+         * A boolean indicating whether controls can be picked/clicked on or not. Defaults to false.
+         */
+        disablePicking: boolean;
         /**
          * If set to true, the POINTERTAP event type will be used for "click", instead of POINTERUP
          */
@@ -4074,13 +4092,9 @@ declare module BABYLON.GUI {
         /**
          * 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)
+         * @param options The options to be used when constructing the ADT
          */
+        constructor(name: string, options?: IAdvancedDynamicTextureOptions);
         constructor(name: string, width?: number, height?: number, scene?: BABYLON.Nullable<BABYLON.Scene>, generateMipMaps?: boolean, samplingMode?: number, invertY?: boolean);
         /**
          * Get the current class name of the texture useful for serialization or dynamic coding.
@@ -4159,7 +4173,8 @@ declare module BABYLON.GUI {
          * @returns the projected position with Z
          */
         getProjectedPositionWithZ(position: BABYLON.Vector3, worldMatrix: BABYLON.Matrix): BABYLON.Vector3;
-        private _checkUpdate;
+        /** @internal */
+        _checkUpdate(camera: BABYLON.Nullable<BABYLON.Camera>, skipUpdate?: boolean): void;
         private _clearMeasure;
         private _render;
         /**
@@ -4337,12 +4352,12 @@ declare module BABYLON.GUI {
          * 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 sceneOrOptions defines the hosting scene or options (IAdvancedDynamicTextureOptions)
          * @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
          */
-        static CreateFullscreenUI(name: string, foreground?: boolean, scene?: BABYLON.Nullable<BABYLON.Scene>, sampling?: number, adaptiveScaling?: boolean): AdvancedDynamicTexture;
+        static CreateFullscreenUI(name: string, foreground?: boolean, sceneOrOptions?: BABYLON.Nullable<BABYLON.Scene> | IAdvancedDynamicTextureOptions, sampling?: number, adaptiveScaling?: boolean): AdvancedDynamicTexture;
         /**
          * Scales the texture
          * @param ratio the scale factor to apply to both width and height
@@ -8198,6 +8213,77 @@ declare module BABYLON.GUI {
     }
 
 
+    /**
+     * Block that implements a fullscreen GUI for render graph
+     */
+    export class NodeRenderGraphGUIBlock extends BABYLON.NodeRenderGraphBlock {
+        protected _frameGraphTask: FrameGraphGUITask;
+        protected _gui: AdvancedDynamicTexture;
+        /**
+         * Gets the frame graph task associated with this block
+         */
+        get task(): FrameGraphGUITask;
+        /**
+         * Gets the GUI texture used by this block
+         */
+        get gui(): AdvancedDynamicTexture;
+        /**
+         * Create a new NodeRenderGraphGUIBlock
+         * @param name defines the block name
+         * @param frameGraph defines the hosting frame graph
+         * @param scene defines the hosting scene
+         */
+        constructor(name: string, frameGraph: BABYLON.FrameGraph, scene: BABYLON.Scene);
+        /**
+         * Gets the current class name
+         * @returns the class name
+         */
+        getClassName(): string;
+        /**
+         * Gets the destination input component
+         */
+        get destination(): BABYLON.NodeRenderGraphConnectionPoint;
+        /**
+         * Gets the output component
+         */
+        get output(): BABYLON.NodeRenderGraphConnectionPoint;
+        protected _buildBlock(state: BABYLON.NodeRenderGraphBuildState): void;
+    }
+
+
+    /**
+     * Task that renders a GUI texture.
+     */
+    export class FrameGraphGUITask extends BABYLON.FrameGraphTask {
+        /**
+         * The destination texture to render the GUI to.
+         */
+        destinationTexture: BABYLON.FrameGraphTextureHandle;
+        /**
+         * The output texture of the task.
+         * This is the same texture as the destination texture, but the handles are different!
+         */
+        readonly outputTexture: BABYLON.FrameGraphTextureHandle;
+        get disabled(): boolean;
+        set disabled(value: boolean);
+        /**
+         * Gets the underlying advanced dynamic texture.
+         */
+        get gui(): AdvancedDynamicTexture;
+        protected _adt: AdvancedDynamicTexture;
+        /**
+         * Constructs a new GUI task.
+         * @param name Name of the task
+         * @param frameGraph Frame graph the task belongs to
+         * @param adt The GUI texture. If not provided, a new fullscreen GUI will be created.
+         */
+        constructor(name: string, frameGraph: BABYLON.FrameGraph, adt?: AdvancedDynamicTexture);
+        isReady(): boolean;
+        record(): void;
+        dispose(): void;
+    }
+
+
 
 }