babylonjs-editor 4.5.0 → 5.4.0-alpha.2

package/declaration/src/editor/layout/inspector/script/script.d.ts

@@ -0,0 +1,18 @@
+import { Component, ReactNode } from "react";
+import { Editor } from "../../../main";
+export interface IScriptInspectorComponent {
+    object: any;
+    editor: Editor;
+}
+export interface IScriptInspectorComponentState {
+    dragOver: boolean;
+    scriptFound: boolean;
+}
+export declare class ScriptInspectorComponent extends Component<IScriptInspectorComponent, IScriptInspectorComponentState> {
+    constructor(props: IScriptInspectorComponent);
+    render(): ReactNode;
+    private _handleRemoveScript;
+    private _getEmptyComponent;
+    private _handleDragOverEmptyComponent;
+    private _handleDropEmptyComponent;
+}

package/declaration/src/editor/layout/inspector/script/tools.d.ts

@@ -0,0 +1,20 @@
+export type VisibleInInspectorDecoratorObject = {
+    label?: string;
+    propertyKey: string;
+    configuration: VisibleInInspectorDecoratorConfiguration;
+    defaultValue?: any;
+};
+export type VisibleInInspectorDecoratorConfiguration = {
+    type: string;
+    description?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    asDegrees?: boolean;
+    noClamp?: boolean;
+    noColorPicker?: boolean;
+    acceptCubes?: boolean;
+    onlyCubes?: boolean;
+};
+export declare const scriptValues = "values";
+export declare function computeDefaultValuesForObject(script: any, output: VisibleInInspectorDecoratorObject[]): void;

package/declaration/src/editor/layout/inspector/sound/sound.d.ts

@@ -0,0 +1,17 @@
+import { Component, ReactNode } from "react";
+import { Sound } from "babylonjs";
+import { IEditorInspectorImplementationProps } from "../inspector";
+export declare class EditorSoundInspector extends Component<IEditorInspectorImplementationProps<Sound>> {
+    /**
+     * Returns whether or not the given object is supported by this inspector.
+     * @param object defines the object to check.
+     * @returns true if the object is supported by this inspector.
+     */
+    static IsSupported(object: unknown): boolean;
+    render(): ReactNode;
+    componentWillUnmount(): void;
+    private _handleCopyName;
+    private _handlePlay;
+    private _handleStop;
+    private _handleReload;
+}

package/declaration/src/editor/layout/inspector/sound/spatial.d.ts

@@ -0,0 +1,14 @@
+import { Component, ReactNode } from "react";
+import { Sound } from "babylonjs";
+export interface IEditorSpatialSoundInspectorComponentProps {
+    sound: Sound;
+}
+export declare class EditorSpatialSoundInspectorComponent extends Component<IEditorSpatialSoundInspectorComponentProps> {
+    render(): ReactNode;
+    private _getDistanceModelComponent;
+    private _getMaxDistanceComponent;
+    private _getRollOffFactorComponent;
+    private _getRefDistanceComponent;
+    private _getPanningModelComponent;
+    private _updateOptions;
+}

package/declaration/src/editor/layout/inspector/sprites/sprite-manager.d.ts

@@ -0,0 +1,27 @@
+import { Component, ReactNode } from "react";
+import { SpriteManagerNode } from "../../../nodes/sprite-manager";
+import { IEditorInspectorImplementationProps } from "../inspector";
+export interface IEditorSpriteManagerNodeInspectorState {
+    dragOver: boolean;
+    isPacked: boolean;
+}
+export declare class EditorSpriteManagerNodeInspector extends Component<IEditorInspectorImplementationProps<SpriteManagerNode>, IEditorSpriteManagerNodeInspectorState> {
+    /**
+     * Returns whether or not the given object is supported by this inspector.
+     * @param object defines the object to check.
+     * @returns true if the object is supported by this inspector.
+     */
+    static IsSupported(object: unknown): boolean;
+    constructor(props: IEditorInspectorImplementationProps<SpriteManagerNode>);
+    render(): ReactNode;
+    private _gizmoObserver;
+    componentDidMount(): Promise<void>;
+    componentWillUnmount(): void;
+    private _computeSpritePreviewImages;
+    private _getCommonSpriteManagerInspector;
+    private _handleCapacityChanged;
+    private _getUnpackedSpriteManagerInspector;
+    private _handleSpritesheetTextureChanged;
+    private _getPackedSpritePreviewsInspector;
+    private _getAtlasJsonDraggableZone;
+}

package/declaration/src/editor/layout/inspector/sprites/sprite-map.d.ts

@@ -0,0 +1,29 @@
+import { Component, ReactNode } from "react";
+import { ISpriteMapTile } from "babylonjs-editor-tools";
+import { SpriteMapNode } from "../../../nodes/sprite-map";
+import { IEditorInspectorImplementationProps } from "../inspector";
+export interface IEditorSpriteMapNodeInspectorState {
+    dragOver: boolean;
+    selectedTile: ISpriteMapTile | null;
+}
+export declare class EditorSpriteMapNodeInspector extends Component<IEditorInspectorImplementationProps<SpriteMapNode>, IEditorSpriteMapNodeInspectorState> {
+    /**
+     * Returns whether or not the given object is supported by this inspector.
+     * @param object defines the object to check.
+     * @returns true if the object is supported by this inspector.
+     */
+    static IsSupported(object: unknown): boolean;
+    constructor(props: IEditorInspectorImplementationProps<SpriteMapNode>);
+    render(): ReactNode;
+    private _gizmoObserver;
+    componentDidMount(): Promise<void>;
+    componentWillUnmount(): void;
+    private _computeSpritePreviewImages;
+    private _getAtlasJsonDraggableZone;
+    private _tilesBeforePan;
+    private _getOptionsInspector;
+    private _getTileInspector;
+    private _handleOptionsUndoRedo;
+    private _handleAddTile;
+    private _handleRemoveTile;
+}

package/declaration/src/editor/layout/inspector/sprites/sprite.d.ts

@@ -0,0 +1,27 @@
+import { Component, ReactNode } from "react";
+import { Sprite } from "babylonjs";
+import { ISpriteAnimation } from "babylonjs-editor-tools";
+import { IEditorInspectorImplementationProps } from "../inspector";
+export interface IEditorSpriteInspectorState {
+    selectedAnimation: ISpriteAnimation | null;
+}
+export declare class EditorSpriteInspector extends Component<IEditorInspectorImplementationProps<Sprite>, IEditorSpriteInspectorState> {
+    /**
+     * Returns whether or not the given object is supported by this inspector.
+     * @param object defines the object to check.
+     * @returns true if the object is supported by this inspector.
+     */
+    static IsSupported(object: unknown): boolean;
+    private _spriteManagerNode;
+    constructor(props: IEditorInspectorImplementationProps<Sprite>);
+    render(): ReactNode;
+    private _gizmoObserver;
+    componentDidMount(): Promise<void>;
+    componentWillUnmount(): void;
+    private _getSpriteAnimationsInspector;
+    private _resetDimensionsFromAtlasJson;
+    private _handleAddAnimation;
+    private _handleRemoveAnimation;
+    private _playOrStopAnimation;
+    private _handleAnimationPropertiesChanged;
+}

package/declaration/src/editor/layout/inspector/transform.d.ts

@@ -0,0 +1,17 @@
+import { Component, ReactNode } from "react";
+import { AbstractMesh, TransformNode } from "babylonjs";
+import { IEditorInspectorImplementationProps } from "./inspector";
+export declare class EditorTransformNodeInspector extends Component<IEditorInspectorImplementationProps<AbstractMesh>> {
+    /**
+     * Returns whether or not the given object is supported by this inspector.
+     * @param object defines the object to check.
+     * @returns true if the object is supported by this inspector.
+     */
+    static IsSupported(object: unknown): boolean;
+    constructor(props: IEditorInspectorImplementationProps<AbstractMesh>);
+    render(): ReactNode;
+    private _gizmoObserver;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    static GetRotationInspector(object: TransformNode, onFinishChange?: () => void): ReactNode;
+}

package/declaration/src/editor/layout/inspector.d.ts

@@ -0,0 +1,24 @@
+import { Component, ReactNode } from "react";
+import { Editor } from "../main";
+export interface IEditorInspectorProps {
+    /**
+     * The editor reference.
+     */
+    editor: Editor;
+}
+export interface IEditorInspectorState {
+    search: string;
+    editedObject: unknown | null;
+}
+export declare class EditorInspector extends Component<IEditorInspectorProps, IEditorInspectorState> {
+    private static _inspectors;
+    constructor(props: IEditorInspectorProps);
+    render(): ReactNode;
+    /**
+     * Sets the edited object.
+     * @param editedObject defines the edited object.
+     */
+    setEditedObject(editedObject: unknown): void;
+    private _getContent;
+    private _handleSearchChanged;
+}

package/declaration/src/editor/layout/marketplace-browser/footer.d.ts

@@ -0,0 +1,11 @@
+export interface IMarketplaceFooterProps {
+    assetsCount: number;
+    currentPage: number;
+    totalCount?: number;
+    loading: boolean;
+    hasPrevious: boolean;
+    hasNext: boolean;
+    onPrevious: () => void;
+    onNext: () => void;
+}
+export declare function MarketplaceFooter(props: IMarketplaceFooterProps): import("react/jsx-runtime").JSX.Element | null;

package/declaration/src/editor/layout/marketplace-browser/grid.d.ts

@@ -0,0 +1,9 @@
+import { IMarketplaceAsset } from "../../../tools/marketplaces/types";
+export interface IMarketplaceGridProps {
+    assets: IMarketplaceAsset[];
+    loading: boolean;
+    query: string;
+    selectedAsset: IMarketplaceAsset | null;
+    onAssetClick: (asset: IMarketplaceAsset) => void;
+}
+export declare const MarketplaceGrid: (props: IMarketplaceGridProps) => import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/marketplace-browser/import-progress.d.ts

@@ -0,0 +1,11 @@
+import { Editor } from "../../main";
+import { IMarketplaceAsset } from "../../../tools/marketplaces/types";
+import { MarketplaceProvider } from "../../../tools/marketplaces/provider";
+export interface IImportProgressProps {
+    asset: IMarketplaceAsset;
+    editor: Editor;
+    provider: MarketplaceProvider;
+    quality: string;
+    type: string;
+}
+export declare const ImportProgress: (props: IImportProgressProps) => import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/marketplace-browser/item.d.ts

@@ -0,0 +1,7 @@
+import { IMarketplaceAsset } from "../../../tools/marketplaces/types";
+export interface IMarketplaceItemProps {
+    asset: IMarketplaceAsset;
+    isSelected: boolean;
+    onClick: () => void;
+}
+export declare const MarketplaceItem: (props: IMarketplaceItemProps) => import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/marketplace-browser/settings-dialog.d.ts

@@ -0,0 +1,21 @@
+import { Component, ReactNode } from "react";
+import { MarketplaceProvider } from "../../../tools/marketplaces/provider";
+export interface IMarketplaceSettingsDialogProps {
+    open: boolean;
+    providers: MarketplaceProvider[];
+    onClose: () => void;
+}
+export interface IMarketplaceSettingsDialogState {
+    downloadPath: string;
+}
+export declare class MarketplaceSettingsDialog extends Component<IMarketplaceSettingsDialogProps, IMarketplaceSettingsDialogState> {
+    constructor(props: IMarketplaceSettingsDialogProps);
+    componentDidUpdate(prevProps: IMarketplaceSettingsDialogProps): void;
+    private _getDownloadPathKey;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private _handleSettingsChanged;
+    render(): ReactNode;
+    private _handleDownloadPathChange;
+    private _handleBrowseDownloadPath;
+}

package/declaration/src/editor/layout/marketplace-browser/sidebar.d.ts

@@ -0,0 +1,19 @@
+import { IMarketplaceAsset } from "../../../tools/marketplaces/types";
+export interface IMarketplaceSidebarProps {
+    asset?: IMarketplaceAsset;
+    detailsLoading: boolean;
+    selectedQuality?: string;
+    selectedType?: string;
+    showLoginAction?: boolean;
+    loginActionLabel?: string;
+    isDownloading: boolean;
+    assetPath?: string;
+    onQualityChange: (quality: string) => void;
+    onTypeChange: (type: string) => void;
+    onImport: (type?: string) => void;
+    onOpenMarketplaceUrl: (url: string) => void;
+    onOpenSettings: () => void;
+    onLogin?: () => void;
+    openAssetFolder: () => void;
+}
+export declare const MarketplaceSidebar: (props: IMarketplaceSidebarProps) => import("react/jsx-runtime").JSX.Element | null;

package/declaration/src/editor/layout/marketplace-browser/toolbar.d.ts

@@ -0,0 +1,17 @@
+import { MarketplaceProvider } from "../../../tools/marketplaces/provider";
+import { IMarketplaceFilterDefinition, IMarketplaceSearchFilters } from "../../../tools/marketplaces/types";
+export interface IMarketplaceToolbarProps {
+    query: string;
+    filters: IMarketplaceSearchFilters;
+    filterDefinitions: IMarketplaceFilterDefinition[];
+    loading: boolean;
+    providers: MarketplaceProvider[];
+    selectedProvider: MarketplaceProvider;
+    onQueryChange: (query: string) => void;
+    onFiltersChange: (filters: IMarketplaceSearchFilters) => void;
+    onResetFilters: () => void;
+    onSearch: () => void;
+    onProviderChange: (provider: MarketplaceProvider) => void;
+    onSettingsClick: () => void;
+}
+export declare function MarketplaceToolbar(props: IMarketplaceToolbarProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/marketplace-browser.d.ts

@@ -0,0 +1,36 @@
+import { Component, ReactNode } from "react";
+import { Editor } from "../main";
+import { MarketplaceProvider } from "../../tools/marketplaces/provider";
+import { IMarketplaceAsset, IMarketplaceSearchFilters } from "../../tools/marketplaces/types";
+export interface IMarketplaceBrowserProps {
+    editor: Editor;
+}
+export interface IMarketplaceBrowserState {
+    providers: MarketplaceProvider[];
+    selectedProvider: MarketplaceProvider;
+    query: string;
+    filters: IMarketplaceSearchFilters;
+    assets: IMarketplaceAsset[];
+    loading: boolean;
+    totalCount?: number;
+    selectedAsset: IMarketplaceAsset | null;
+    currentPage: number;
+    pageTokenStack: (string | undefined)[];
+    nextPageToken?: string;
+    settingsOpen: boolean;
+    isMaximized: boolean;
+}
+export declare class EditorMarketplaceBrowser extends Component<IMarketplaceBrowserProps, IMarketplaceBrowserState> {
+    private _searchRequestId;
+    constructor(props: IMarketplaceBrowserProps);
+    componentDidMount(): Promise<void>;
+    componentWillUnmount(): void;
+    private _handleSettingsChanged;
+    private _handleLayoutChanged;
+    render(): ReactNode;
+    private _handlePreviousPage;
+    private _handleNextPage;
+    private _handleAssetClicked;
+    private _handleSearch;
+    private _getDefaultFilters;
+}

package/declaration/src/editor/layout/navmesh/components/list.d.ts

@@ -0,0 +1,10 @@
+import { AbstractMesh, Scene } from "babylonjs";
+import { INavMeshObstacleConfiguration, INavMeshStaticMeshConfiguration } from "../types";
+export interface INavMeshEditorListComponentProps<T> {
+    scene: Scene;
+    search: string;
+    items: T[];
+    onCreateItem: (mesh: AbstractMesh) => T;
+    onItemsChange: (items: T[], updateNavMesh: boolean) => void;
+}
+export declare function NavMeshEditorListComponent<T extends INavMeshStaticMeshConfiguration | INavMeshObstacleConfiguration>(props: INavMeshEditorListComponentProps<T>): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/navmesh/components/search.d.ts

@@ -0,0 +1,5 @@
+export interface INavMeshEditorSearchComponentProps {
+    search: string;
+    setSearch: (value: string) => void;
+}
+export declare function NavMeshEditorSearchComponent(props: INavMeshEditorSearchComponentProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/navmesh/editor.d.ts

@@ -0,0 +1,34 @@
+import { Component, ReactNode } from "react";
+import { CreateNavMeshResult } from "babylonjs-addons/navigation/types";
+import { RecastNavigationJSPluginV2 } from "babylonjs-addons";
+import { Editor } from "../../main";
+import { INavMeshConfiguration } from "./types";
+export interface INavmeshEditorProps {
+    editor: Editor;
+    configuration: INavMeshConfiguration;
+    absolutePath: string;
+}
+export interface INavmeshEditorState {
+    initializing: boolean;
+}
+export declare class NavMeshEditor extends Component<INavmeshEditorProps, INavmeshEditorState> {
+    configuration: INavMeshConfiguration;
+    plugin: RecastNavigationJSPluginV2;
+    result: CreateNavMeshResult | null;
+    private _debugNavMesh;
+    private _debugObstacles;
+    constructor(props: INavmeshEditorProps);
+    render(): ReactNode;
+    componentDidMount(): Promise<void>;
+    componentWillUnmount(): void;
+    refreshAll(): Promise<void>;
+    updateNavMesh(): Promise<void>;
+    createDebugObstacles(): Promise<void>;
+    private _disposeDebugObstacles;
+    save(): Promise<void>;
+    private _createPlugin;
+    private _disposePlugin;
+    private _createDebugNavMesh;
+    private _disposeDebugNavMesh;
+    private _getLoadingScreen;
+}

package/declaration/src/editor/layout/navmesh/inspector.d.ts

@@ -0,0 +1,7 @@
+import { Editor } from "../../main";
+import { NavMeshEditor } from "./editor";
+export interface INavMeshEditorInspectorProps {
+    editor: Editor;
+    navMeshEditor: NavMeshEditor;
+}
+export declare function NavMeshEditorInspector(props: INavMeshEditorInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/navmesh/meshes.d.ts

@@ -0,0 +1,7 @@
+import { Editor } from "../../main";
+import { NavMeshEditor } from "./editor";
+export interface INavMeshEditorMeshesListProps {
+    editor: Editor;
+    navMeshEditor: NavMeshEditor;
+}
+export declare function NavMeshEditorMeshesList(props: INavMeshEditorMeshesListProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/navmesh/obstacles.d.ts

@@ -0,0 +1,7 @@
+import { Editor } from "../../main";
+import { NavMeshEditor } from "./editor";
+export interface INavMeshEditorObstaclesProps {
+    editor: Editor;
+    navMeshEditor: NavMeshEditor;
+}
+export declare function NavMeshEditorObstacles(props: INavMeshEditorObstaclesProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/navmesh/preview.d.ts

@@ -0,0 +1,7 @@
+import { RecastNavigationJSPluginV2 } from "babylonjs-addons";
+import { Mesh } from "babylonjs";
+export interface INavMeshEditorPreviewProps {
+    mesh: Mesh | null;
+    plugin: RecastNavigationJSPluginV2;
+}
+export declare function NavMeshEditorPreview(props: INavMeshEditorPreviewProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/navmesh/toolbar.d.ts

@@ -0,0 +1,5 @@
+import { NavMeshEditor } from "./editor";
+export interface INavMeshEditorToolbarProps {
+    navMeshEditor: NavMeshEditor;
+}
+export declare function NavMeshEditorToolbar(props: INavMeshEditorToolbarProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/navmesh/tools.d.ts

@@ -0,0 +1,10 @@
+import { Scene, AbstractMesh } from "babylonjs";
+import { INavMeshObstacleConfiguration, INavMeshStaticMeshConfiguration } from "./types";
+export declare function getStaticMeshes(scene: Scene, configurations: INavMeshStaticMeshConfiguration[]): {
+    clonedMeshes: AbstractMesh[];
+    effectiveStaticMeshes: import("babylonjs").Mesh[];
+};
+export declare function getObstacleMeshes(scene: Scene, configurations: INavMeshObstacleConfiguration[]): {
+    clone: import("babylonjs").Mesh;
+    config: INavMeshObstacleConfiguration;
+}[];

package/declaration/src/editor/layout/navmesh/types.d.ts

@@ -0,0 +1,20 @@
+import { INavMeshParametersV2 } from "babylonjs-addons/navigation/types";
+export interface INavMeshConfiguration {
+    navMeshParameters: INavMeshParametersV2;
+    staticMeshes: INavMeshStaticMeshConfiguration[];
+    obstacleMeshes: INavMeshObstacleConfiguration[];
+}
+export interface INavMeshStaticMeshConfiguration {
+    id: string;
+    enabled: boolean;
+}
+export interface INavMeshObstacleConfiguration {
+    id: string;
+    enabled: boolean;
+    type: "box" | "cylinder";
+    position?: number[];
+    extent?: number[];
+    angle?: number;
+    radius?: number;
+    height?: number;
+}

package/declaration/src/editor/layout/preview/axis.d.ts

@@ -0,0 +1,30 @@
+import { Component, ReactNode } from "react";
+import { Scene, AbstractMesh, Vector2 } from "babylonjs";
+import { Editor } from "../../main";
+export interface IEditorPreviewAxisHelperProps {
+    editor: Editor;
+}
+export interface IEditorPreviewAxisHelperState {
+    xLabelPosition: Vector2;
+    yLabelPosition: Vector2;
+    zLabelPosition: Vector2;
+}
+export declare class EditorPreviewAxisHelper extends Component<IEditorPreviewAxisHelperProps, IEditorPreviewAxisHelperState> {
+    scene: Scene | null;
+    /** @internal */
+    _axisMeshUnderPointer: AbstractMesh | null;
+    private _axisClickableMeshes;
+    constructor(props: IEditorPreviewAxisHelperProps);
+    render(): ReactNode;
+    componentWillUnmount(): void;
+    /**
+     * Gets wether or not icons are enabled.
+     */
+    get enabled(): boolean;
+    stop(): Promise<void>;
+    start(): Promise<void>;
+    private _checkAxisUnderPointer;
+    private _handlePointerTap;
+    private _createAxis;
+    private _createNegativeAlphaSphere;
+}

package/declaration/src/editor/layout/preview/camera.d.ts

@@ -0,0 +1,8 @@
+import { Camera } from "babylonjs";
+import { Editor } from "../../main";
+export interface IEditorPreviewCameraProps {
+    editor: Editor;
+    camera: Camera;
+    hidden?: boolean;
+}
+export declare function EditorPreviewCamera(props: IEditorPreviewCameraProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/preview/gizmo.d.ts

@@ -0,0 +1,45 @@
+import { GizmoCoordinatesMode, Node, Observable, PositionGizmo, RotationGizmo, ScaleGizmo, Scene, UtilityLayerRenderer, Sprite } from "babylonjs";
+export declare const onGizmoNodeChangedObservable: Observable<Node | Sprite>;
+export declare class EditorPreviewGizmo {
+    /**
+     * @internal
+     */
+    _gizmosLayer: UtilityLayerRenderer;
+    private _scalingGizmo;
+    private _positionGizmo;
+    private _rotationGizmo;
+    private _coordinatesMode;
+    private _cameraGizmo;
+    private _attachedNode;
+    private _attachedSprite;
+    private _spriteTransformNode;
+    constructor(scene: Scene);
+    /**
+     * Gets the current gizmo.
+     */
+    get currentGizmo(): PositionGizmo | RotationGizmo | ScaleGizmo | null;
+    /**
+     * Sets the gizmo type.
+     * @param gizmo The gizmo to set.
+     */
+    setGizmoType(gizmo: "position" | "rotation" | "scaling" | "none"): void;
+    /**
+     * Gets the reference to the node that is attached and controlled by the gizmo.
+     */
+    get attachedNode(): Node | null;
+    /**
+     * Gets the reference to the sprite that is attached and controlled by the gizmo.
+     */
+    get attachedSprite(): Sprite | null;
+    /**
+     * Sets the node that is attached and controlled by the gizmo.
+     * @param object The node to attach to the gizmo.
+     */
+    setAttachedObject(object: Node | Sprite | null): void;
+    getCoordinateMode(): GizmoCoordinatesMode;
+    setCoordinatesMode(mode: GizmoCoordinatesMode): void;
+    getCoordinatesModeString(): string;
+    private _updateShadowMapsForMesh;
+    private _attachVector3UndoRedoEvents;
+    private _attachRotationUndoRedoEvents;
+}

package/declaration/src/editor/layout/preview/icons.d.ts

@@ -0,0 +1,35 @@
+import { Component, ReactNode } from "react";
+import { Node, Vector2, Sound } from "babylonjs";
+import { Editor } from "../../main";
+export interface IEditorPreviewIconsProps {
+    editor: Editor;
+}
+export interface IEditorPreviewIconsState {
+    buttons: _IButtonData[];
+}
+interface _IButtonData {
+    position: Vector2;
+    node: Node | Sound;
+}
+export declare class EditorPreviewIcons extends Component<IEditorPreviewIconsProps, IEditorPreviewIconsState> {
+    private _tempMesh;
+    private _renderFunction;
+    constructor(props: IEditorPreviewIconsProps);
+    render(): ReactNode;
+    componentWillUnmount(): void;
+    /**
+     * Gets wether or not icons are enabled.
+     */
+    get enabled(): boolean;
+    /**
+     * Starts rendering icons on the preview scene.
+     */
+    start(): void;
+    private _isInFrustrum;
+    /**
+     * Stops rendering icons on the preview scene.
+     */
+    stop(): void;
+    private _getIcon;
+}
+export {};

package/declaration/src/editor/layout/preview/import/gui.d.ts

@@ -0,0 +1,8 @@
+import { AdvancedDynamicTexture } from "babylonjs-gui";
+import { Editor } from "../../../main";
+/**
+ * Imports the GUI file located at the given absolute path and adds it to the scene.
+ * @param editor defines the reference to the editor.
+ * @param absolutePath defines the absolute path to the GUI file to import.
+ */
+export declare function applyImportedGuiFile(editor: Editor, absolutePath: string): Promise<AdvancedDynamicTexture | undefined>;

package/declaration/src/editor/layout/preview/import/import.d.ts

@@ -0,0 +1,9 @@
+import { CubeTexture, ISceneLoaderAsyncResult, Material, Node, Scene, Texture, ColorGradingTexture, Sprite, IParticleSystem } from "babylonjs";
+export declare function tryConvertSceneFile(absolutePath: string, progress?: (percent: number) => void): Promise<string>;
+export declare function loadImportedSceneFile(scene: Scene, absolutePath: string): Promise<ISceneLoaderAsyncResult | null>;
+export declare function configureImportedNodeIds(node: Node | Sprite | IParticleSystem): void;
+export declare function configureImportedMaterial(material: Material): void;
+export declare function configureImportedTexture<T extends Texture | CubeTexture | ColorGradingTexture>(texture: T, noCheckInvertY?: boolean): T;
+export declare function configureEmbeddedTexture(texture: Texture, absolutePath: string): Promise<unknown>;
+export declare function loadImportedMaterial(scene: Scene, absolutePath: string): Promise<Material | null>;
+export declare function cleanImportedGltf(result: ISceneLoaderAsyncResult): void;

package/declaration/src/editor/layout/preview/import/material.d.ts

@@ -0,0 +1,16 @@
+import { Material } from "babylonjs";
+import { Editor } from "../../../main";
+/**
+ * Applies the material asset located at the given absolute path to the given object.
+ * @param editor defines the reference to the editor.
+ * @param object defines the reference to the object where to apply the material. The type of the object is tested to be an AbstractMesh.
+ * @param absolutePath defines the absolute path to the .material asset file.
+ */
+export declare function applyMaterialAssetToObject(editor: Editor, object: any, absolutePath: string): void;
+/**
+ * Applies the given material to the given object.
+ * @param editor defines the reference to the editor.
+ * @param object defines the reference to the object where to apply the material. The type of the object is tested to be an AbstractMesh.
+ * @param material defines the reference to the material instance to apply on the object.
+ */
+export declare function applyMaterialToObject(editor: Editor, object: any, material: Material): void;

package/declaration/src/editor/layout/preview/import/particles.d.ts

@@ -0,0 +1,3 @@
+import { Scene, AbstractMesh } from "babylonjs";
+import { NodeParticleSystemSetMesh } from "../../../nodes/node-particle-system";
+export declare function loadImportedParticleSystemFile(scene: Scene, targetMesh: AbstractMesh, absolutePath: string): Promise<NodeParticleSystemSetMesh>;