babylonjs-addons 8.29.0 → 8.29.2

package/babylonjs.addons.d.ts

@@ -2,6 +2,1319 @@
 declare module ADDONS {
 
 
+    /**
+     * Recast injection type
+     */
+    export type RecastInjection = any;
+    /**
+     * Off-mesh connection data
+     */
+    export interface IOffMeshConnection {
+        /**
+         * The start position of the off-mesh connection.
+         */
+        startPosition: BABYLON.IVector3Like;
+        /**
+         * The end position of the off-mesh connection.
+         */
+        endPosition: BABYLON.IVector3Like;
+        /**
+         * The radius of the off-mesh connection.
+         */
+        radius: number;
+        /**
+         * The type of the off-mesh connection.
+         */
+        bidirectional: boolean;
+        /**
+         * The area type of the off-mesh connection.
+         */
+        area: number;
+        /**
+         * The flags of the off-mesh connection.
+         */
+        flags: number;
+        /**
+         * The user ID of the off-mesh connection.
+         * @remarks This can be used to associate the off-mesh connection with a specific user
+         */
+        userId?: number;
+    }
+    /**
+     * Result of a navigation mesh creation.
+     */
+    export type CreateNavMeshResult = BABYLON.Nullable<{
+        /**
+         * Navigation mesh
+         */
+        navMesh: any;
+        /**
+         * Navigation mesh query
+         */
+        navMeshQuery: any;
+        /**
+         * Intermediates generated during the any creation process.
+         * @remarks This is only available if the `keepIntermediates` parameter is set to true in the `INavMeshParametersV2`.
+         * It can be used for debugging or visualization purposes.
+         */
+        intermediates?: GeneratorIntermediates;
+        /**
+         * Tile cache generated during the any creation process.
+         * @remarks This is only available if the `maxObstacles` parameter is set to a value greater than 0 in the `INavMeshParametersV2`. Defaults `maxObstacles` to 128.
+         * It can be used for obstacle avoidance and dynamic navigation mesh updates.
+         * @see {@link INavMeshParametersV2}
+         */
+        tileCache?: any;
+    }>;
+    /**
+     * Agent parameters
+     * For actual limits and default values check the recast-navigation-js docs.
+     * @see https://docs.recast-navigation-js.isaacmason.com/types/index.CrowdAgentParams.html
+     */
+    export interface IAgentParametersV2 extends BABYLON.IAgentParameters {
+        /**
+         * Flags that impact steering behavior.
+         */
+        updateFlags: number;
+        /**
+         * The index of the avoidance configuration to use for the agent. [Limits: 0 to #DT_CROWD_MAX_OBSTAVOIDANCE_PARAMS inclusive]
+         */
+        obstacleAvoidanceType: number;
+        /**
+         * The index of the query filter used by this agent.
+         */
+        queryFilterType: number;
+        /**
+         * User defined data attached to the agent.
+         */
+        userData: unknown;
+    }
+    /**
+     * any parameters
+     * For actual limits and default values check the recast-navigation-js docs.
+     * @see https://docs.recast-navigation-js.isaacmason.com/types/index.RecastConfig.html
+     */
+    export interface INavMeshParametersV2 extends BABYLON.INavMeshParameters {
+        /**
+         * OffMeshConnections - Teleports
+         */
+        offMeshConnections?: IOffMeshConnection[];
+        /**
+         * Whether to keep intermediate navigation mesh data for debug visualization. Default is false.
+         */
+        keepIntermediates?: boolean;
+        /**
+         * The maximum number of obstacles that can be added to the navigation mesh. Default is 32.
+         * If this value is greater then 0, the navigation mesh will be generated with a tile cache.
+         */
+        maxObstacles?: number;
+        /**
+         * The size of each tile in the tiled navigation mesh. Default is 32.
+         */
+        expectedLayersPerTile?: number;
+        /**
+         * Function which is sets the polyAreas and polyFlags for the tile cache mesh. Defaults to a function that sets all areas to 0 and flags to 1.
+         */
+        tileCacheMeshProcess?: any;
+    }
+    /**
+     * Result of a steer target computation.
+     */
+    export type SteerTargetResult = {
+        /**
+         * Indicates whether the steering target computation was successful.
+         */
+        success: false;
+    } | {
+        /**
+         * Indicates whether the steering target computation was successful.
+         */
+        success: true;
+        /**
+         * The position to steer towards.
+         */
+        steerPos: BABYLON.Vector3;
+        /**
+         * The flag indicating the type of steering position.
+         */
+        steerPosFlag: number;
+        /**
+         * The reference to the polygon that the steering position is associated with.
+         */
+        steerPosRef: number;
+        /**
+         * The points that make up the path to the steering position.
+         */
+        points: BABYLON.Vector3[];
+    };
+    /**
+     * Error types for path computation.
+     */
+    export var ComputePathError: {
+        START_NEAREST_POLY_FAILED: string;
+        END_NEAREST_POLY_FAILED: string;
+        FIND_PATH_FAILED: string;
+        NO_POLYGON_PATH_FOUND: string;
+        NO_CLOSEST_POINT_ON_LAST_POLYGON_FOUND: string;
+    };
+    export type ComputePathErrorType = (typeof ComputePathError)[keyof typeof ComputePathError];
+    /**
+     * Result of a path computation.
+     */
+    export type ComputePathResult = {
+        /**
+         * Indicates whether the path computation was successful.
+         */
+        success: boolean;
+        /**
+         * The error message if the path computation failed.
+         */
+        error?: {
+            /**
+             * A descriptive error message.
+             */
+            name?: string;
+            /**
+             * The type of error that occurred during path computation.
+             * @remarks This will be one of the values from `ComputePathError`
+             */
+            type?: ComputePathErrorType;
+            /**
+             * Statusring describing the error.
+             */
+            status?: number;
+        };
+        /**
+         * The computed path as an array of BABYLON.Vector3 points.
+         */
+        path: BABYLON.IVector3Like[];
+    };
+    /**
+     * Intermediates generated during the any creation process.
+     * @remarks This is only available if the `keepIntermediates` parameter is set to true in the `INavMeshParametersV2`.
+     * It can be used for debugging or visualization purposes.
+     */
+    export type GeneratorIntermediates = any | any | any | null;
+
+
+
+
+    /**
+     * Generates a navigation mesh in a web worker.
+     */
+    export function GenerateNavMeshWorker(): void;
+
+
+
+
+    /**
+     * Navigation plugin for Babylon.js. It is a simple wrapper around the recast-navigation-js library. Not all features are implemented.
+     * @remarks This plugin provides navigation mesh generation and pathfinding capabilities using the recast-navigation-js library
+     * @remarks It supports both single-threaded and multi-threaded generation of navigation meshes.
+     * @remarks The plugin can be used to create navigation meshes from meshes in a scene, compute paths, and manage crowd agents, etc.
+     * @remarks It also provides methods for creating obstacles and querying the navigation mesh.
+     * @see https://github.com/isaac-mason/recast-navigation-js
+     */
+    export class RecastNavigationJSPluginV2 implements BABYLON.INavigationEnginePlugin {
+        /**
+         *  Creates a navigation mesh - will be injected by the factory
+         * @param meshes array of all the geometry used to compute the navigation mesh
+         * @param parameters bunch of parameters used to filter geometry
+         * @returns the created navmesh and navmesh query
+         */
+        createNavMeshImpl: (meshes: Array<BABYLON.Mesh>, parameters: INavMeshParametersV2) => CreateNavMeshResult;
+        /**
+         * Creates a navigation mesh - will be injected by the factory
+         * @param meshes array of all the geometry used to compute the navigation mesh
+         * @param parameters bunch of parameters used to filter geometry
+         * @returns the created navmesh and navmesh query
+         */
+        createNavMeshAsyncImpl: (meshes: Array<BABYLON.Mesh>, parameters: INavMeshParametersV2) => Promise<CreateNavMeshResult>;
+        /**
+         * recast-navigation-js injection
+         */
+        bjsRECAST: RecastInjection;
+        /**
+         * plugin name
+         */
+        name: string;
+        /**
+         * the navmesh created
+         */
+        navMesh?: any;
+        /**
+         * The navmesh query created from the navmesh
+         * @remarks This is used to query the navmesh for pathfinding and other navigation tasks
+         */
+        get navMeshQuery(): any;
+        private _navMeshQuery;
+        /**
+         * Intermediates generated during the navmesh creation
+         * @remarks This is used for debugging and visualization purposes.
+         * @remarks You have access to vertices, indices and vertex colors to visusalize the navmesh creation process.
+         * @remarks This is only available if the `keepIntermediates` parameter is set
+         * @remarks to true during navmesh generation.
+         */
+        private _intermediates?;
+        /**
+         * Gets the intermediates generated during the navmesh creation
+         * @returns The generator intermediates, or undefined if not available
+         */
+        get intermediates(): GeneratorIntermediates | undefined;
+        /**
+         * Tile cache used for tiled navigation meshes
+         * @remarks This is used to store and manage tiles of the navigation mesh for efficient path and when obstacles are used.
+         */
+        private _tileCache?;
+        /**
+         * Gets the tile cache used for tiled navigation meshes
+         * @returns The tile cache instance, or undefined if not available
+         */
+        get tileCache(): any | undefined;
+        private _maximumSubStepCount;
+        private _timeStep;
+        private _timeFactor;
+        private _crowd?;
+        /**
+         * Creates a RecastNavigationJSPluginV2 instance
+         * @param recastInjection The recast-navigation-js injection containing core and generators
+         */
+        constructor(recastInjection?: RecastInjection);
+        /**
+         * Set the time step of the navigation tick update.
+         * Default is 1/60.
+         * A value of 0 will disable fixed time update
+         * @param newTimeStep the new timestep to apply to this world.
+         */
+        setTimeStep(newTimeStep?: number): void;
+        /**
+         * Get the time step of the navigation tick update.
+         * @returns the current time step
+         */
+        getTimeStep(): number;
+        /**
+         * If delta time in navigation tick update is greater than the time step
+         * a number of sub iterations are done. If more iterations are need to reach deltatime
+         * they will be discarded.
+         * A value of 0 will set to no maximum and update will use as many substeps as needed
+         * @param newStepCount the maximum number of iterations
+         */
+        setMaximumSubStepCount(newStepCount?: number): void;
+        /**
+         * Get the maximum number of iterations per navigation tick update
+         * @returns the maximum number of iterations
+         */
+        getMaximumSubStepCount(): number;
+        /**
+         * Time factor applied when updating crowd agents (default 1). A value of 0 will pause crowd updates.
+         * @param value the time factor applied at update
+         */
+        set timeFactor(value: number);
+        /**
+         * Get the time factor used for crowd agent update
+         * @returns the time factor
+         */
+        get timeFactor(): number;
+        /**
+         * Creates a navigation mesh - will be injected by the factory
+         * @param meshes array of all the geometry used to compute the navigation mesh
+         * @param parameters bunch of parameters used to filter geometry
+         * @returns the created navmesh and navmesh query
+         * @throws Error if the function is not injected yet or if the navmesh is not created
+         */
+        createNavMesh(meshes: Array<BABYLON.Mesh>, parameters: INavMeshParametersV2): CreateNavMeshResult;
+        /**
+         * Creates a navigation mesh asynchronously - will be injected by the factory
+         * @param meshes array of all the geometry used to compute the navigation mesh
+         * @param parameters bunch of parameters used to filter geometry
+         * @returns the created navmesh and navmesh query
+         * @throws Error if the function is not injected yet or if the navmesh is not created
+         */
+        createNavMeshAsync(meshes: Array<BABYLON.Mesh>, parameters: INavMeshParametersV2): Promise<CreateNavMeshResult>;
+        /**
+         * Create a navigation mesh debug mesh
+         * @param scene is where the mesh will be added
+         * @returns debug display mesh
+         */
+        createDebugNavMesh(scene: BABYLON.Scene): BABYLON.Mesh;
+        /**
+         * Get a navigation mesh constrained position, closest to the parameter position
+         * @param position world position
+         * @returns the closest point to position constrained by the navigation mesh
+         */
+        getClosestPoint(position: BABYLON.IVector3Like, options?: {
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * Half extents for the search box
+             */
+            halfExtents?: BABYLON.IVector3Like;
+        }): BABYLON.Vector3;
+        /**
+         * Get a navigation mesh constrained position, closest to the parameter position
+         * @param position world position
+         * @param result output the closest point to position constrained by the navigation mesh
+         */
+        getClosestPointToRef(position: BABYLON.IVector3Like, result: BABYLON.Vector3, options?: {
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * Half extents for the search box
+             */
+            halfExtents?: BABYLON.IVector3Like;
+        }): void;
+        /**
+         * Get a navigation mesh constrained position, within a particular radius
+         * @param position world position
+         * @param maxRadius the maximum distance to the constrained world position
+         * @returns the closest point to position constrained by the navigation mesh
+         */
+        getRandomPointAround(position: BABYLON.IVector3Like, maxRadius: number, options?: {
+            startRef?: number;
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * Half extents for the search box
+             */
+            halfExtents?: BABYLON.IVector3Like;
+        }): BABYLON.Vector3;
+        /**
+         * Get a navigation mesh constrained position, within a particular radius
+         * @param position world position
+         * @param maxRadius the maximum distance to the constrained world position
+         * @param result output the closest point to position constrained by the navigation mesh
+         */
+        getRandomPointAroundToRef(position: BABYLON.IVector3Like, maxRadius: number, result: BABYLON.Vector3, options?: {
+            startRef?: number;
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * Half extents for the search box
+             */
+            halfExtents?: BABYLON.IVector3Like;
+        }): void;
+        /**
+         * Compute the final position from a segment made of destination-position
+         * @param position position to start from
+         * @param destination position to go to
+         * @param startRef the reference id of the start polygon
+         * @param options options for the function
+         * @returns the resulting point along the navmesh
+         */
+        moveAlong(position: BABYLON.IVector3Like, destination: BABYLON.IVector3Like, startRef?: number, options?: {
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * The maximum number of polygons the output visited array can hold.
+             */
+            maxVisitedSize?: number;
+        }): BABYLON.Vector3;
+        /**
+         * Compute the final position from a segment made of destination-position
+         * @param position world position
+         * @param destination world position
+         * @param result output the resulting point along the navmesh
+         * @param startRef the reference id of the start polygon.
+         * @param options options for the function
+         */
+        moveAlongToRef(position: BABYLON.IVector3Like, destination: BABYLON.IVector3Like, result: BABYLON.Vector3, startRef?: number, options?: {
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            maxVisitedSize?: number;
+        }): void;
+        /**
+         * Compute a navigation path from start to end. Returns an empty array if no path can be computed
+         * Path is straight.
+         * @param start world position
+         * @param end world position
+         * @param options options for the function
+         * @returns array containing world position composing the path
+         */
+        computePath(start: BABYLON.IVector3Like, end: BABYLON.IVector3Like, options?: {
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * Half extents for the search box
+             */
+            halfExtents?: BABYLON.IVector3Like;
+            maxPathPolys?: number;
+            maxStraightPathPoints?: number;
+        }): BABYLON.Vector3[];
+        /**
+         * Creates a navigation mesh - will be injected by the factory
+         * @param start the start position of the navmesh
+         * @param end the end position of the navmesh
+         * @param options options to configure the path computation
+         * @returns array containing world position composing the path
+         */
+        computePathSmooth(start: BABYLON.Vector3, end: BABYLON.Vector3, options?: {
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * Half extents for the search box
+             */
+            halfExtents?: BABYLON.IVector3Like;
+            maxPathPolys?: number;
+            maxSmoothPathPoints?: number;
+            stepSize?: number;
+            slop?: number;
+        }): BABYLON.Vector3[];
+        /**
+         * Create a new Crowd so you can add agents
+         * @param maxAgents the maximum agent count in the crowd
+         * @param maxAgentRadius the maximum radius an agent can have
+         * @param scene to attach the crowd to
+         * @returns the crowd you can add agents to
+         */
+        createCrowd(maxAgents: number, maxAgentRadius: number, scene: BABYLON.Scene): BABYLON.ICrowd;
+        /**
+         * Set the Bounding box extent for doing spatial queries (getClosestPoint, getRandomPointAround, ...)
+         * The queries will try to find a solution within those bounds
+         * default is (1,1,1)
+         * @param extent x,y,z value that define the extent around the queries point of reference
+         */
+        setDefaultQueryExtent(extent: BABYLON.IVector3Like): void;
+        /**
+         * Get the Bounding box extent specified by setDefaultQueryExtent
+         * @returns the box extent values
+         */
+        getDefaultQueryExtent(): BABYLON.Vector3;
+        /**
+         * Get the Bounding box extent result specified by setDefaultQueryExtent
+         * @param result output the box extent values
+         */
+        getDefaultQueryExtentToRef(result: BABYLON.Vector3): void;
+        /**
+         * build the navmesh from a previously saved state using getNavmeshData
+         * @param data the Uint8Array returned by getNavmeshData
+         */
+        buildFromNavmeshData(data: Uint8Array): void;
+        /**
+         * returns the navmesh data that can be used later. The navmesh must be built before retrieving the data
+         * @returns data the Uint8Array that can be saved and reused
+         */
+        getNavmeshData(): Uint8Array;
+        /**
+         * build the tile cache from a previously saved state using getTileCacheData
+         * @param tileCacheData the data returned by getTileCacheData
+         * @param tileCacheMeshProcess optional process to apply to each tile created
+         */
+        buildFromTileCacheData(tileCacheData: Uint8Array, tileCacheMeshProcess?: any): void;
+        /**
+         * returns the tile cache data that can be used later. The tile cache must be built before retrieving the data
+         * @returns the tile cache data that can be used later. The tile cache must be built before retrieving the data
+         * @throws Error if there is no any generated
+         * @remarks The returned data can be used to rebuild the tile cache later using buildFromTileCacheData
+         */
+        getTileCacheData(): Uint8Array;
+        /**
+         * Disposes
+         */
+        dispose(): void;
+        /**
+         * Creates a cylinder obstacle and add it to the navigation
+         * @param position world position
+         * @param radius cylinder radius
+         * @param height cylinder height
+         * @param doNotWaitForCacheUpdate if true the function will not wait for the tile cache to be fully updated before returning
+         * @returns the obstacle freshly created
+         */
+        addCylinderObstacle(position: BABYLON.IVector3Like, radius: number, height: number, doNotWaitForCacheUpdate?: boolean): BABYLON.Nullable<BABYLON.IObstacle>;
+        /**
+         * Creates an oriented box obstacle and add it to the navigation
+         * @param position world position
+         * @param extent box size
+         * @param angle angle in radians of the box orientation on Y axis
+         * @param doNotWaitForCacheUpdate if true the function will not wait for the tile cache to be fully updated before returning
+         * @returns the obstacle freshly created
+         */
+        addBoxObstacle(position: BABYLON.IVector3Like, extent: BABYLON.IVector3Like, angle: number, doNotWaitForCacheUpdate?: boolean): BABYLON.Nullable<BABYLON.IObstacle>;
+        /**
+         * Removes an obstacle created by addCylinderObstacle or addBoxObstacle
+         * @param obstacle obstacle to remove from the navigation
+         * @param doNotWaitForCacheUpdate if true the function will not wait for the tile cache to be fully updated before returning
+         *
+         */
+        removeObstacle(obstacle: BABYLON.IObstacle, doNotWaitForCacheUpdate?: boolean): void;
+        /**
+         * If this plugin is supported
+         * @returns true if plugin is supported
+         */
+        isSupported(): boolean;
+        /**
+         * Returns the seed used for randomized functions like `getRandomPointAround`
+         * @returns seed number
+         */
+        getRandomSeed(): number;
+        /**
+         * Set the seed used for randomized functions like `getRandomPointAround`
+         * @param seed number used as seed for random functions
+         */
+        setRandomSeed(seed: number): void;
+        /**
+         * Perform a raycast on the navmesh
+         * @param start start position
+         * @param end end position
+         * @returns if a direct path exists between start and end, and the hit point if any
+         */
+        raycast(start: BABYLON.IVector3Like, end: BABYLON.IVector3Like): {
+            hit: boolean;
+            hitPoint?: undefined;
+        } | {
+            hit: boolean;
+            hitPoint: BABYLON.Vector3;
+        };
+        /**
+         * Compute the final position from a segment made of destination-position, and return the height of the polygon
+         * This is a more sophisiticated version of moveAlong that will use the height of the polygon at the end position
+         * @param position world position to start from
+         * @param velocity wvelocity of the movement
+         * @param options options for the function
+         * @returns the resulting point along the navmesh, the polygon reference id and the height of the polygon
+         */
+        moveAlongWithVelocity(position: BABYLON.IVector3Like, velocity: BABYLON.IVector3Like, options?: {
+            /**
+             * The polygon filter to apply to the query.
+             */
+            filter?: any;
+            /**
+             * Half extents for the search box
+             */
+            halfExtents?: BABYLON.IVector3Like;
+            /**
+             * The maximum number of polygons the output visited array can hold.
+             */
+            maxVisitedSize?: number;
+        }): {
+            position: {
+                x: number;
+                y: number;
+                z: number;
+            };
+            polyRef: number;
+            height: number;
+        };
+        /**
+         * Handles common post-processing and validation of navmesh creation results
+         * @param result The partial result from navmesh creation
+         * @returns The validated and complete CreateNavMeshresult
+         */
+        private _processNavMeshResult;
+        private _preprocessParameters;
+    }
+
+
+    /**
+     * Recast Detour crowd implementation
+     * This class provides methods to manage a crowd of agents, allowing them to navigate a navigation mesh.
+     * It supports adding agents, updating their parameters, moving them to destinations, and checking their states.
+     * The crowd is updated in the scene's animation loop, and it notifies observers when agents reach their destinations.
+     */
+    export class RecastJSCrowd implements BABYLON.ICrowd {
+        /**
+         * Recast plugin
+         */
+        get navigationPlugin(): RecastNavigationJSPluginV2;
+        /**
+         * Link to the detour crowd
+         */
+        get recastCrowd(): any;
+        /**
+         * One transform per agent
+         */
+        get transforms(): BABYLON.TransformNode[];
+        /**
+         * All agents created
+         */
+        get agents(): readonly number[];
+        /**
+         * Agents reach radius
+         */
+        get reachRadii(): readonly number[];
+        private _navigationPlugin;
+        private _recastCrowd;
+        private _transforms;
+        private _agents;
+        private _reachRadii;
+        /**
+         * true when a destination is active for an agent and notifier hasn't been notified of reach
+         */
+        private _agentDestinationArmed;
+        /**
+         * agent current target
+         */
+        private _agentDestination;
+        /**
+         * Link to the scene is kept to unregister the crowd from the scene
+         */
+        private _scene;
+        private _engine;
+        /**
+         * Observer for crowd updates
+         */
+        private _onBeforeAnimationsObserver;
+        /**
+         * Fires each time an agent is in reach radius of its destination
+         */
+        onReachTargetObservable: BABYLON.Observable<{
+            /**
+             *
+             */
+            agentIndex: number;
+            /**
+             *
+             */
+            destination: BABYLON.Vector3;
+        }>;
+        /**
+         * Constructor
+         * @param plugin recastJS plugin
+         * @param maxAgents the maximum agent count in the crowd
+         * @param maxAgentRadius the maximum radius an agent can have
+         * @param scene to attach the crowd to
+         * @returns the crowd you can add agents to
+         */
+        constructor(plugin: RecastNavigationJSPluginV2, maxAgents: number, maxAgentRadius: number, scene: BABYLON.Scene);
+        /**
+         * Add a new agent to the crowd with the specified parameter a corresponding transformNode.
+         * You can attach anything to that node. The node position is updated in the scene update tick.
+         * @param pos world position that will be constrained by the navigation mesh
+         * @param parameters agent parameters
+         * @param transform hooked to the agent that will be update by the scene
+         * @returns agent index
+         */
+        addAgent(pos: BABYLON.IVector3Like, parameters: IAgentParametersV2, transform: BABYLON.TransformNode): number;
+        /**
+         * Returns the agent position in world space
+         * @param index agent index returned by addAgent
+         * @returns world space position
+         */
+        getAgentPosition(index: number): BABYLON.Vector3;
+        /**
+         * Returns the agent position result in world space
+         * @param index agent index returned by addAgent
+         * @param result output world space position
+         */
+        getAgentPositionToRef(index: number, result: BABYLON.Vector3): void;
+        /**
+         * Returns the agent velocity in world space
+         * @param index agent index returned by addAgent
+         * @returns world space velocity
+         */
+        getAgentVelocity(index: number): BABYLON.Vector3;
+        /**
+         * Returns the agent velocity result in world space
+         * @param index agent index returned by addAgent
+         * @param result output world space velocity
+         */
+        getAgentVelocityToRef(index: number, result: BABYLON.Vector3): void;
+        /**
+         * Returns the agent next target point on the path
+         * @param index agent index returned by addAgent
+         * @returns world space position
+         */
+        getAgentNextTargetPath(index: number): BABYLON.Vector3;
+        /**
+         * Returns the agent next target point on the path
+         * @param index agent index returned by addAgent
+         * @param result output world space position
+         */
+        getAgentNextTargetPathToRef(index: number, result: BABYLON.Vector3): void;
+        /**
+         * Gets the agent state
+         * @param index agent index returned by addAgent
+         * @returns agent state, 0 = DT_CROWDAGENT_STATE_INVALID, 1 = DT_CROWDAGENT_STATE_WALKING, 2 = DT_CROWDAGENT_STATE_OFFMESH
+         */
+        getAgentState(index: number): number;
+        /**
+         * returns true if the agent in over an off mesh link connection
+         * @param index agent index returned by addAgent
+         * @returns true if over an off mesh link connection
+         */
+        overOffmeshConnection(index: number): boolean;
+        /**
+         * Asks a particular agent to go to a destination. That destination is constrained by the navigation mesh
+         * @param index agent index returned by addAgent
+         * @param destination targeted world position
+         */
+        agentGoto(index: number, destination: BABYLON.IVector3Like): void;
+        /**
+         * Teleport the agent to a new position
+         * @param index agent index returned by addAgent
+         * @param destination targeted world position
+         */
+        agentTeleport(index: number, destination: BABYLON.IVector3Like): void;
+        /**
+         * Update agent parameters
+         * @param index agent index returned by addAgent
+         * @param parameters agent parameters
+         */
+        updateAgentParameters(index: number, parameters: IAgentParametersV2): void;
+        /**
+         * remove a particular agent previously created
+         * @param index agent index returned by addAgent
+         */
+        removeAgent(index: number): void;
+        /**
+         * get the list of all agents attached to this crowd
+         * @returns list of agent indices
+         */
+        getAgents(): number[];
+        /**
+         * Tick update done by the BABYLON.Scene. Agent position/velocity/acceleration is updated by this function
+         * @param deltaTime in seconds
+         */
+        update(deltaTime: number): void;
+        /**
+         * Set the Bounding box extent for doing spatial queries (getClosestPoint, getRandomPointAround, ...)
+         * The queries will try to find a solution within those bounds
+         * default is (1,1,1)
+         * @param extent x,y,z value that define the extent around the queries point of reference
+         */
+        setDefaultQueryExtent(extent: BABYLON.IVector3Like): void;
+        /**
+         * Get the Bounding box extent specified by setDefaultQueryExtent
+         * @returns the box extent values
+         */
+        getDefaultQueryExtent(): BABYLON.Vector3;
+        /**
+         * Get the Bounding box extent result specified by setDefaultQueryExtent
+         * @param result output the box extent values
+         */
+        getDefaultQueryExtentToRef(result: BABYLON.Vector3): void;
+        /**
+         * Get the next corner points composing the path (max 4 points)
+         * @param index agent index returned by addAgent
+         * @returns array containing world position composing the path
+         */
+        getCorners(index: number): BABYLON.Vector3[];
+        /**
+         * Release all resources
+         */
+        dispose(): void;
+    }
+
+
+    /**
+     * Injects the navigation mesh generation methods into the navigation plugin.
+     * @param navigationPlugin The navigation plugin to inject the methods into.
+     */
+    export function InjectGenerators(navigationPlugin: RecastNavigationJSPluginV2): void;
+
+
+
+
+    /**
+     * IMPORTANT!
+     * This file is still under construction and will change in the future.
+     * Workers are not yet supported.
+     * For more info visit: https://forum.babylonjs.com/t/replacing-recastjs-with-recast-navigation-js/56003/46
+     */
+    /**
+     * Builds a any and any from meshes using provided parameters.
+     * @param meshes The array of meshes used to create the any
+     * @param parameters The parameters used to configure the any generation.
+     * @param workerOptions Options for the worker, including a completion callback and the worker instance.
+     * @throws Error if the any data is invalid or cannot be deserialized.
+     */
+    export function GenerateNavMeshWithWorker(meshes: Array<BABYLON.Mesh>, parameters: INavMeshParametersV2, workerOptions: {
+        /**
+         * Completion callback that is called when the any generation is complete.
+         * @param navMesh The generated any
+         * @param navMeshQuery The any associated with the generated any
+         * @param tileCache Optional any if tile cache generation was used.
+         */
+        completion: (navMesh: any, navMeshQuery: any, tileCache?: any) => void;
+        /**
+         *  Worker instance used for asynchronous any generation.
+         */
+        worker: Worker;
+    }): void;
+
+
+    /**
+     * Builds a NavMesh and NavMeshQuery from meshes using provided parameters.
+     * @param meshes The array of meshes used to create the NavMesh.
+     * @param parameters The parameters used to configure the NavMesh generation.
+     * @returns An object containing the NavMesh and NavMeshQuery.
+     * @remarks This function generates a NavMesh based on the provided meshes and parameters.
+     * It supports different configurations such as solo, tiled, and tile cache nav meshes.
+     * If you need obstacles, ensure that `maxObstacles` is set to a value greater than 0.
+     * Recommended values for `tileSize` are between 32 and 64 when using obstacles/tile cache.
+     * If you need a tiled nav mesh, ensure that `tileSize` is set to a value greater than 0.
+     * @throws Error if the NavMesh data is invalid or cannot be deserialized.
+     */
+    export function GenerateNavMesh(meshes: Array<BABYLON.Mesh>, parameters: INavMeshParametersV2): {
+        navMesh: any;
+        intermediates: any;
+        navMeshQuery: any;
+        tileCache: any;
+    };
+
+
+    /**
+     *  Builds a NavMesh and NavMeshQuery from serialized data.
+     *  @param data The serialized NavMesh data.
+     *  @returns An object containing the NavMesh and NavMeshQuery.
+     *  @remarks This function deserializes the NavMesh data and creates a NavMeshQuery
+     *  instance for querying the NavMesh.
+     *  @throws Error if the NavMesh data is invalid or cannot be deserialized.
+     */
+    export function BuildFromNavmeshData(data: Uint8Array): {
+        navMesh: any;
+        navMeshQuery: any;
+        tileCache: undefined;
+    };
+    /**
+     * Builds a TileCache and NavMeshQuery from serialized data.
+     * @param data The serialized TileCache data.
+     * @param tileCacheMeshProcess Optional function to process the TileCache mesh.
+     * @returns An object containing the TileCache, NavMesh, and NavMeshQuery.
+     */
+    export function BuildFromTileCacheData(data: Uint8Array, tileCacheMeshProcess: any): {
+        navMesh: any;
+        navMeshQuery: any;
+        tileCache: any;
+    };
+
+
+
+
+    /**
+     * Creates a navigation plugin for the given scene using a worker.
+     * @returns A promise that resolves to the created navigation plugin.
+     * @remarks This function initializes the Recast module and sets up the navigation plugin to use a worker.
+     * The worker is used to handle the creation of the navigation mesh asynchronously.
+     * The `createNavMesh` method is not supported in worker mode, use `createNavMeshAsync` instead.
+     */
+    export function CreateNavigationPluginWorkerAsync(): Promise<RecastNavigationJSPluginV2>;
+
+
+    /**
+     * Creates a navigation plugin for the given scene.
+     * @returns A promise that resolves to the created navigation plugin.
+     * @remarks This function initializes the Recast module and sets up the navigation plugin.
+     */
+    export function CreateNavigationPluginAsync(): Promise<RecastNavigationJSPluginV2>;
+
+
+    /**
+     * Gets the RecastInjection instance (reference to the recast-navigation-js library).
+     * @returns The RecastInjection instance
+     * @throws Error if Recast is not initialized
+     */
+    export function GetRecast(): RecastInjection;
+    /**
+     * Sets the RecastInjection instance (reference to the recast-navigation-js library).
+     * @param recast The RecastInjection instance to set
+     */
+    export function SetRecast(recast: RecastInjection): void;
+    /**
+     * Initialize the Manifold library
+     * @param version defines the version of the library to use, default is "0.43.0"
+     * @param options defines the options to use to initialize the library
+     */
+    export function InitRecast(version?: string, options?: {
+        instance: RecastInjection;
+    }): Promise<void>;
+
+
+    /**
+     * Creates a debug mesh for visualizing a any in the scene.
+     * @param navMesh The any to visualize.
+     * @param scene The scene in which to create the debug mesh.
+     * @param parent Optional parent node for the debug mesh.
+     * @param flags Poly flags to filter by, defaults to undefined to include all polys
+     * @returns The created debug mesh.
+     */
+    export function CreateDebugNavMesh(navMesh: any, scene: BABYLON.Scene, parent?: BABYLON.Node, flags?: number): BABYLON.Mesh;
+
+
+
+
+    export var DebugLayerOption: {
+        HEIGHTFIELD_SOLID: string;
+        HEIGHTFIELD_WALKABLE: string;
+        COMPACT_HEIGHTFIELD_SOLID: string;
+        COMPACT_HEIGHTFIELD_REGIONS: string;
+        COMPACT_HEIGHTFIELD_DISTANCE: string;
+        RAW_CONTOURS: string;
+        CONTOURS: string;
+        POLY_MESH: string;
+        POLY_MESH_DETAIL: string;
+        NAVMESH: string;
+        NAVMESH_BV_TREE: string;
+    };
+    export type DebugLayerOptions = (typeof DebugLayerOption)[keyof typeof DebugLayerOption];
+    /**
+     * NavigationDebugger is a utility class for visualizing navigation meshes and related data in a Babylon.js scene.
+     * It provides methods to draw various navigation-related primitives such as points, lines, triangles, and quads.
+     * It also supports drawing heightfields, compact heightfields, contours, poly meshes, and nav meshes.
+     */
+    export class NavigationDebugger {
+        private _scene;
+        /**
+         *  The name of the debug mesh used for navigation debugging.
+         *  This is used to group all navigation debug meshes under a single name for easier management
+         */
+        static NAV_MESH_DEBUG_NAME: string;
+        /**
+         * The name of the debug mesh used for visualization of the navigation mesh using points.
+         */
+        static NAV_MESH_DEBUG_NAME_POINTS: string;
+        /**
+         * The name of the debug mesh used for visualization of the navigation mesh using triangles.
+         */
+        static NAV_MESH_DEBUG_NAME_TRIS: string;
+        /**
+         * The name of the debug mesh used for visualization of the navigation mesh using quads.
+         */
+        static NAV_MESH_DEBUG_NAME_QUADS: string;
+        /**
+         * The name of the debug mesh used for visualization of the navigation mesh using lines.
+         */
+        static NAV_MESH_DEBUG_NAME_LINES: string;
+        /**
+         * The material used for rendering triangles in the navigation debug visualization.
+         */
+        triMaterial: BABYLON.StandardMaterial;
+        /**
+         * The material used for rendering points in the navigation debug visualization.
+         */
+        pointMaterial: BABYLON.StandardMaterial;
+        /**
+         * The list of line materials used in the navigation debug visualization.
+         */
+        lineMaterials: BABYLON.StandardMaterial[];
+        /**
+         * The parent node for the debug drawer.
+         */
+        debugDrawerParentNode: BABYLON.TransformNode;
+        /**
+         * * Gets or sets the primitive types to be drawn by the debug drawer.
+         * * This allows you to control which types of primitives (points, lines, tris, quads) are rendered in the navigation debug visualization.
+         * * The default value is `["points", "lines", "tris", "quads"]`.
+         * * You can modify this property to include or exclude specific primitive types based on your debugging needs.
+         * @returns An array of primitive types that the debug drawer will render.
+         */
+        get primitiveTypes(): any;
+        set primitiveTypes(value: any);
+        private _lineMaterialOptions;
+        private _pointMesh;
+        private _debugDrawerUtils;
+        private _primitiveTypes;
+        constructor(_scene: BABYLON.Scene, options?: {
+            parent?: {
+                node?: BABYLON.TransformNode | string;
+            };
+            primitiveTypes?: any;
+            materials?: {
+                triMaterial?: BABYLON.StandardMaterial;
+                pointMaterial?: BABYLON.StandardMaterial;
+                lineMaterialOptions: {
+                    greasedLineMaterialOptions: Partial<BABYLON.GreasedLineMaterialOptions>;
+                    greasedLineMeshOptions: Partial<BABYLON.GreasedLineMeshOptions>;
+                };
+            };
+        });
+        /**
+         * Resets the debug drawer by disposing of all child meshes in the debug drawer parent node.
+         * This is useful for clearing the debug visualization before drawing new primitives.
+         */
+        clear(): void;
+        /**
+         * Disposes of the debug drawer, including all meshes and materials used for rendering.
+         * This method should be called when the debug drawer is no longer needed to free up resources.
+         */
+        dispose(): void;
+        /**
+         * This method iterates through the provided primitives and draws them based on their type.
+         * It supports drawing points, lines, triangles, and quads, depending on the primitive type.
+         * @param primitives An array of debug drawer primitives to be drawn.
+         * @param options Optional parameters to control the drawing behavior, such as whether to join meshes.
+         */
+        drawPrimitives(primitives: any, options?: {
+            joinMeshes?: boolean;
+        }): void;
+        /**
+         * Draws a heightfield as solid using the debug drawer utilities.
+         * @param hf The heightfield to draw as solid.
+         */
+        drawHeightfieldSolid(hf: any): void;
+        /**
+         * Draws a heightfield as walkable using the debug drawer utilities.
+         * @param hf The heightfield to draw as walkable.
+         */
+        drawHeightfieldWalkable(hf: any): void;
+        /**
+         * Draws a compact heightfield as solid using the debug drawer utilities.
+         * @param chf The compact heightfield to draw as solid.
+         */
+        drawCompactHeightfieldSolid(chf: any): void;
+        /**
+         * Draws the regions of a compact heightfield using the debug drawer utilities.
+         * @param chf The compact heightfield to draw regions for.
+         */
+        drawCompactHeightfieldRegions(chf: any): void;
+        /**
+         * Draws the distance field of a compact heightfield using the debug drawer utilities.
+         * @param chf The compact heightfield to draw the distance for.
+         */
+        drawCompactHeightfieldDistance(chf: any): void;
+        /**
+         * Draws a heightfield layer using the debug drawer utilities.
+         * @param layer The heightfield layer to draw.
+         * @param idx The index of the layer to draw.
+         */
+        drawHeightfieldLayer(layer: any, idx: number): void;
+        /**
+         * Draws the layers of a heightfield using the debug drawer utilities.
+         * @param lset The heightfield layer set containing the layers to draw.
+         */
+        drawHeightfieldLayers(lset: any): void;
+        /**
+         * Draws the region connections of a any using the debug drawer utilities.
+         * @param cset any to draw
+         * @param alpha The alpha value for the drawn contours, default is 1.
+         */
+        drawRegionConnections(cset: any, alpha?: number): void;
+        /**
+         * Draws raw contours from a any using the debug drawer utilities.
+         * @param cset any to draw
+         * @param alpha The alpha value for the drawn contours, default is 1.
+         */
+        drawRawContours(cset: any, alpha?: number): void;
+        /**
+         * Draws contours from a any using the debug drawer utilities.
+         * @param cset any to draw
+         * @param alpha The alpha value for the drawn contours, default is 1.
+         */
+        drawContours(cset: any, alpha?: number): void;
+        /**
+         * Draws a poly mesh using the debug drawer utilities.
+         * @param mesh any to draw
+         */
+        drawPolyMesh(mesh: any): void;
+        /**
+         * Draws a poly mesh detail using the debug drawer utilities.
+         * @param dmesh any to draw
+         */
+        drawPolyMeshDetail(dmesh: any): void;
+        /**
+         * Draws a any using the debug drawer utilities.
+         * @param mesh any to draw
+         * @param flags Flags to control the drawing behavior, default is 0.
+         */
+        drawNavMesh(mesh: any, flags?: number): void;
+        /**
+         * Draws a any with closed list using the debug drawer utilities.
+         * @param mesh any to draw
+         * @param query any to use for drawing the closed list.
+         * @param flags Flags to control the drawing behavior, default is 0.
+         */
+        drawNavMeshWithClosedList(mesh: any, query: any, flags?: number): void;
+        /**
+         * Draws the nodes of a any using the debug drawer utilities.
+         * @param query any to use for drawing the nodes.
+         */
+        drawNavMeshNodes(query: any): void;
+        /**
+         * Draws the bounding volume tree of a any using the debug drawer utilities.
+         * @param mesh any to draw the bounding volume tree for.
+         */
+        drawNavMeshBVTree(mesh: any): void;
+        /**
+         * Draws the portals of a any using the debug drawer utilities.
+         * @param mesh any to draw the portals for.
+         */
+        drawNavMeshPortals(mesh: any): void;
+        /**
+         * Draws polygons of a any with specific flags using the debug drawer utilities.
+         * @param mesh any to draw the polygons with specific flags.
+         * @param flags The flags to filter the polygons to be drawn.
+         * @param col The color to use for the drawn polygons, represented as a number.
+         */
+        drawNavMeshPolysWithFlags(mesh: any, flags: number, col: number): void;
+        /**
+         * Draws polygons of a any with specific reference and color using the debug drawer utilities.
+         * @param mesh any to draw the polygons with specific reference and color.
+         * @param ref The reference number of the polygons to be drawn.
+         * @param col The color to use for the drawn polygons, represented as a number.
+         */
+        drawNavMeshPoly(mesh: any, ref: number, col: number): void;
+        /**
+         *  Get the intermediates from the generator
+         *  @param intermediates - The generator intermediates
+         *  @returns An object containing lists of heightfields, compact heightfields, contour sets
+         */
+        getIntermediates: (intermediates: GeneratorIntermediates) => {
+            heightfieldList: any;
+            compactHeightfieldList: any;
+            contourSetList: any;
+            polyMeshList: any;
+            polyMeshDetailList: any;
+        };
+        /**
+         *  Draw debug information based on the selected option
+         *  @param navMesh - The navigation mesh to draw
+         *  @param intermediates - The generator intermediates containing the data to draw
+         *  @param scene - The scene to draw in
+         *  @param option - The debug drawer option to use
+         *  @remarks This method will reset the debug drawer before drawing.
+         */
+        draw(navMesh: any, intermediates: GeneratorIntermediates, scene: BABYLON.Scene, option: DebugLayerOptions): void;
+        private _drawPoints;
+        private _drawLines;
+        private _drawTris;
+        private _drawQuads;
+        /**
+         * Merge the debug meshes for better performance
+         */
+        private _joinDebugMeshes;
+        private _convertUnindexedToIndexed;
+    }
+
+
+    /**
+     * Utility function based on Chaikin's alogrithm for navigation path smoothing and segment generation.
+     * @param points Array of points to be smoothed, where each point is an object with x, y, and z properties.
+     * @param iterations Number of smoothing iterations to apply. Default 1.
+     * @returns A new array of smoothed points after applying the Chaikin's algorithm.
+     */
+    export function GetChaikinSmoothPath(points: BABYLON.IVector3Like[], iterations?: number): BABYLON.IVector3Like[];
+    /**
+     *  Generates a series of points that create an L-shaped path between each pair of points in the input navigation segment.
+     *  The path consists of a horizontal segment followed by a vertical segment, or vice versa,
+     *  depending on the relative distances between the x and z coordinates of the points.
+     * @param navSegment An array of BABYLON.Vector3 points representing the navigation segment.
+     * @returns An array of BABYLON.Vector3 points representing the L-shaped path.
+     */
+    export function GetLShapedPath(navSegment: BABYLON.Vector3[]): BABYLON.Vector3[];
+
+
+    /**
+     * Creates a default tile cache mesh process function
+     * @param offMeshConnections offMeshConnections
+     * @param area the area to be set for each poly
+     * @param flags the flags to be set for each poly
+     * @returns the tile cache mesh process function
+     */
+    export function CreateDefaultTileCacheMeshProcess(offMeshConnections?: any, area?: number, flags?: number): any;
+    /**
+     * Waits until the tile cache is fully updated
+     * @param navMesh The any
+     * @param tileCache THe any
+     */
+    export function WaitForFullTileCacheUpdate(navMesh: any, tileCache: any): void;
+
+
+    /**
+     * Compute a smooth navigation path from start to end. Returns an empty array if no path can be computed
+     * @param navMesh the navigation mesh to use
+     * @param navmeshQuery the navigation mesh query to use
+     * @param start world position
+     * @param end world position
+     * @param options options object
+     * @returns array containing world position composing the path
+     */
+    export function ComputeSmoothPath(navMesh: any, navmeshQuery: any, start: BABYLON.IVector3Like, end: BABYLON.IVector3Like, options?: {
+        filter?: any;
+        halfExtents?: BABYLON.IVector3Like;
+        /**
+         * @default 256
+         */
+        maxPathPolys?: number;
+        /**
+         * @default 2048
+         */
+        maxSmoothPathPoints?: number;
+        /**
+         * @default 0.5
+         */
+        stepSize?: number;
+        /**
+         * @default 0.01
+         */
+        slop?: number;
+    }): BABYLON.Vector3[];
+
+
+
+
+    /**
+     *  Extracts positions and indices from an array of meshes.
+     *  @param meshes The array of meshes from which to extract positions and indices.
+     *  @returns A tuple containing a Float32Array of positions and a Uint32Array of
+     */
+    export function GetPositionsAndIndices(meshes: BABYLON.Mesh[]): [positions: Float32Array, indices: Uint32Array];
+    /**
+     * Reverses the order of vertices in each triangle (3 indices per face) to ensure
+     * that the winding order is consistent with the Recast Navigation requirements.
+     * This is necessary because Recast Navigation expects the indices to be in a specific winding order.
+     * @param meshOrIndices The mesh from which to extract indices or the indices themselves.
+     * @returns Array of indices with reversed winding order.
+     */
+    export function GetReversedIndices(meshOrIndices: BABYLON.Mesh | Uint32Array | number[]): Uint32Array<ArrayBufferLike> | number[] | Int32Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | null;
+
+
+    /**
+     *  Converts navigation path points to a BABYLON.Vector3 array.
+     *  @param navPath The navigation path containing points and success status.
+     *  @returns An array of BABYLON.Vector3 points representing the navigation path.
+     */
+    export function ConvertNavPathPoints(navPath: ComputePathResult): BABYLON.Vector3[];
+
+
+    export const DefaultMaxObstacles = 128;
+    /**
+     * Creates a SoloNavMesh configuration based on the provided parameters.
+     * @param parameters The parameters used to configure the SoloNavMesh generation.
+     * @returns A configuration object for generating a SoloNavMesh.
+     * @see https://docs.recast-navigation-js.isaacmason.com/types/index.RecastConfig.html
+     */
+    export function CreateSoloNavMeshConfig(parameters: INavMeshParametersV2): Partial<any>;
+    /**
+     * Creates a TiledNavMesh configuration based on the provided parameters.
+     * @param parameters The parameters used to configure the TiledNavMesh generation.
+     * @returns A configuration object for generating a TiledNavMesh.
+     */
+    export function CreateTiledNavMeshConfig(parameters: INavMeshParametersV2): Partial<any>;
+    /**
+     * Creates a TileCacheNavMesh configuration based on the provided parameters.
+     * @param parameters The parameters used to configure the TileCacheNavMesh generation.
+     * @returns A configuration object for generating a TileCacheNavMesh.
+     */
+    export function CreateTileCacheNavMeshConfig(parameters: INavMeshParametersV2): Partial<any>;
+    /**
+     * Convert IAgentParameters to Recast any
+     * @param config Agent parameters
+     * @returns Recast crowd agent paramaters
+     */
+    export function ToSoloNavMeshGeneratorConfig(config: INavMeshParametersV2): Partial<any>;
+    /**
+     * Convert IAgentParameters to Recast any
+     * @param agentParams Agent parameters
+     * @returns Recast crowd agent paramaters
+     */
+    export function ToCrowdAgentParams(agentParams: IAgentParametersV2): Partial<any>;
+
+
     /**
      * Abstract Node class from Babylon.js
      */
@@ -126,6 +1439,18 @@ declare module ADDONS {
     }
 
 
+    export interface ISdfTextParagraphMetrics {
+        /** @internal */
+        readonly paragraph: string;
+        /** @internal */
+        readonly lines: SdfTextLine[];
+        /** @internal */
+        readonly width: number;
+        /** @internal */
+        readonly height: number;
+        /** @internal */
+        readonly glyphs: SdfGlyph[];
+    }
     /** @internal */
     export type ParagraphOptions = {
         maxWidth: number;
@@ -135,6 +1460,7 @@ declare module ADDONS {
         whiteSpace: "pre-line";
         textAlign: "left" | "right" | "center";
         translate: BABYLON.IVector2Like | undefined;
+        customLayoutEngine?: (text: string, options: ParagraphOptions) => ISdfTextParagraphMetrics;
     };
     /** @internal */
     export var DefaultParagraphOptions: ParagraphOptions;