babylonjs-editor 4.4.0 → 5.2.4

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

@@ -0,0 +1,16 @@
+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;
+    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/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/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,2 @@
+import { Scene, ParticleSystemSet, AbstractMesh } from "babylonjs";
+export declare function loadImportedParticleSystemFile(scene: Scene, targetMesh: AbstractMesh, absolutePath: string): Promise<ParticleSystemSet | null>;

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

@@ -0,0 +1,11 @@
+import { Component, ReactNode } from "react";
+export interface IEditorPreviewConvertProgressProps {
+    absolutePath: string;
+}
+export interface IEditorPreviewConvertProgressState {
+    value: number;
+}
+export declare class EditorPreviewConvertProgress extends Component<IEditorPreviewConvertProgressProps, IEditorPreviewConvertProgressState> {
+    constructor(props: IEditorPreviewConvertProgressProps);
+    render(): ReactNode;
+}

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

@@ -0,0 +1,2 @@
+import { Editor } from "../../../main";
+export declare function applySoundAsset(editor: Editor, object: any, absolutePath: string): Promise<import("../../../../ui/dialog").DialogReturnType | undefined>;

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

@@ -0,0 +1,17 @@
+import { CubeTexture, Texture, ColorGradingTexture } from "babylonjs";
+import { Editor } from "../../../main";
+/**
+ * Applies the texture 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 texture. The type of the object is tested.
+ * @param absolutePath defines the absolute path to the texture asset file (.png, .env, .jpg, etc.).
+ */
+export declare function applyTextureAssetToObject(editor: Editor, object: any, absolutePath: string): void;
+/**
+ * Applies the given texture to the given object. Tries to determine the correct slot to apply the texture.
+ * If fails, asks to choose the slot (albedo, bump, etc.).
+ * @param editor defines the reference to the editor.
+ * @param object defines the reference to the object where to apply the texture. The type of the object is tested.
+ * @param texture defines the reference to the texture instance to apply on the object.
+ */
+export declare function applyTextureToObject(editor: Editor, object: any, texture: Texture | CubeTexture | ColorGradingTexture): void;

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

@@ -0,0 +1,92 @@
+import { Component, ReactNode } from "react";
+import { Scene } from "babylonjs";
+import { Editor } from "../../main";
+export interface IEditorPreviewPlayComponentProps {
+    /**
+     * The editor reference.
+     */
+    editor: Editor;
+    /**
+     * Defines wether or not the play button is enabled in the preview.
+     */
+    enabled: boolean;
+    /**
+     * Called on the user wants to restart the game / application (aka. refresh the page of the game / application).
+     */
+    onRestart: () => void;
+}
+export interface IEditorPreviewPlayComponentState {
+    /**
+     * Defines wether or not the player is being prepared.
+     */
+    preparingPlay: boolean;
+    /**
+     * Defines wether or not the game / application is currently loading.
+     */
+    loading: boolean;
+    /**
+     * Defines wether or not the game / application is playing in the editor.
+     */
+    playing: boolean;
+}
+export declare class EditorPreviewPlayComponent extends Component<IEditorPreviewPlayComponentProps, IEditorPreviewPlayComponentState> {
+    /**
+     * Defines the reference to the scene that is reserved for the game / application when playing.
+     * This scene is used to be renderer directly in the preview panel of the editor and is disposed when the
+     * game / application is stopped.
+     */
+    scene: Scene | null;
+    private _srcWatcher;
+    private _temporaryDirectory;
+    private _compiledScriptExports;
+    constructor(props: IEditorPreviewPlayComponentProps);
+    render(): ReactNode;
+    componentDidMount(): void;
+    triggerPlayScene(): void;
+    componentDidUpdate(_: Readonly<IEditorPreviewPlayComponentProps>, prevState: Readonly<IEditorPreviewPlayComponentState>): void;
+    /**
+     * Gets wether or not everything is ready to play the current scene of the game / application.
+     */
+    get canPlayScene(): boolean;
+    /**
+     * Sets the game / application to play or stop.
+     * If the game / application is not playing, it will start it.
+     * If the game / application is playing, it will stop it.
+     */
+    playOrStopApplication(): Promise<void>;
+    /**
+     * Restarts the game / application.
+     * This will just clean the current scene instance (event receivers, etc.) and reload the same scene.
+     */
+    restart(): Promise<void>;
+    /**
+     * Stops the game / application.
+     * It will dispose the scene and reset the state.
+     */
+    stop(): void;
+    /**
+     * Starts the game / application.
+     * The play process consists on:
+     * - the exporting the final scene without optimizations (to save export time)
+     * - compiling the scripts map using esbuild (located at projectAbsoluteDir/src/scripts.ts)
+     * - store the output of esbuild and put it in the temporary directory of the project (.bjseditor folder)
+     * - require the compiled script and use babylonjs-editor-tools to render the scene.
+     */
+    play(noExportScene?: boolean, noCompile?: boolean): Promise<void>;
+    /**
+     * The script that is required and executed is a bundled version of the "src/scripts.ts" file.
+     * Here we use esbuild to bundle the scripts and transform the imports to use the correct paths.
+     * @see compilePlayScript for more information.
+     */
+    private _compileScripts;
+    private _createAndLoadScene;
+    private _requireCompiledScripts;
+    /**
+     * Watches all the src directory of the project to detect changes in the scripts.
+     * If a change is detected, it will restart the game / application.
+     * TODO: change only those one that changed.
+     */
+    private _watchSrcDirectory;
+    private _closeWatchSrcDirectory;
+    hotReloadScript(scriptKey: string, compile: boolean): void;
+}

package/declaration/src/editor/layout/preview/stats/row.d.ts

@@ -0,0 +1,5 @@
+export interface IStatRowProps {
+    label: string;
+    value?: number;
+}
+export declare function StatRow(props: IStatRowProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,17 @@
+import { Observable } from "babylonjs";
+import { Editor } from "../../../main";
+import { StatsValuesType } from "./types";
+export declare class Stats {
+    /**
+     * Defines the observable called when the stats values have been updated.
+     */
+    onValuesChangedObservable: Observable<StatsValuesType>;
+    private _editor;
+    private _intervalId;
+    private _values;
+    private _engineInstrumentation;
+    private _sceneInstrumentation;
+    constructor(editor: Editor);
+    dispose(): void;
+    private _computeStats;
+}

package/declaration/src/editor/layout/preview/stats/types.d.ts

@@ -0,0 +1,28 @@
+export type StatsValuesType = {
+    averageFPS?: number;
+    instantaneousFPS?: number;
+    averageFrameTime?: number;
+    instantaneousFrameTime?: number;
+    activeFaces?: number;
+    activeIndices?: number;
+    activeBones?: number;
+    activeParticles?: number;
+    activeMeshes?: number;
+    drawCalls?: number;
+    totalVertices?: number;
+    totalMeshes?: number;
+    totalMaterials?: number;
+    totalTextures?: number;
+    totalLights?: number;
+    gpuFrameTime?: number;
+    gpuFrameTimeAvarage?: number;
+    absoluteFPS?: number;
+    render?: number;
+    frameTotal?: number;
+    interFrame?: number;
+    meshSelection?: number;
+    renderTargets?: number;
+    animations?: number;
+    particles?: number;
+    physics?: number;
+};

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

@@ -0,0 +1,140 @@
+import { Component, ReactNode } from "react";
+import { AbstractEngine, Camera, ISceneLoaderAsyncResult, Scene } from "babylonjs";
+import { Editor } from "../main";
+import { EditorCamera } from "../nodes/camera";
+import { EditorPreviewGizmo } from "./preview/gizmo";
+import { EditorPreviewIcons } from "./preview/icons";
+import { EditorPreviewAxisHelper } from "./preview/axis";
+import { EditorPreviewPlayComponent } from "./preview/play";
+import { Stats } from "./preview/stats/stats";
+import { StatsValuesType } from "./preview/stats/types";
+export interface IEditorPreviewProps {
+    /**
+     * The editor reference.
+     */
+    editor: Editor;
+}
+export interface IEditorPreviewState {
+    /**
+     * Defines the information message drawn over the preview to tell the user what is happening.
+     */
+    informationMessage: ReactNode;
+    isFocused: boolean;
+    rightClickedObject?: any;
+    pickingEnabled: boolean;
+    showStatsValues: boolean;
+    statsValues?: StatsValuesType;
+    playEnabled: boolean;
+    playSceneLoadingProgress: number;
+    activeGizmo: "position" | "rotation" | "scaling" | "none";
+    /**
+     * Defines the fixed dimensions of the preview canvas.
+     * "fit" means the canvas will fit the entire panel container.
+     */
+    fixedDimensions: "720p" | "1080p" | "4k" | "fit";
+}
+export declare class EditorPreview extends Component<IEditorPreviewProps, IEditorPreviewState> {
+    /**
+     * The engine of the preview.
+     */
+    engine: AbstractEngine;
+    /**
+     * The scene of the preview.
+     */
+    scene: Scene;
+    /**
+     * The camera of the preview.
+     */
+    camera: EditorCamera;
+    /**
+     * The gizmo manager of the preview
+     */
+    gizmo: EditorPreviewGizmo;
+    /**
+     * The helper drawn over the scene to help visualizing and selecting nodes like lights, cameras, particle systems, etc.
+     */
+    icons: EditorPreviewIcons;
+    /**
+     * The helper drawn over the scene to help visualizing the axis according to the current camera view.
+     */
+    axis: EditorPreviewAxisHelper;
+    /**
+     * The play component of the preview.
+     */
+    play: EditorPreviewPlayComponent;
+    /**
+     * The current statistics of the preview.
+     * This is used to display the FPS and other values.
+     */
+    statistics: Stats;
+    /**
+     * Defines the reference to the canvas drawn in the preview.
+     */
+    canvas: HTMLCanvasElement | null;
+    private _renderScene;
+    private _mouseDownPosition;
+    private _objectUnderPointer;
+    private _workingCanvas;
+    private _mainView;
+    /** @internal */
+    _previewCamera: Camera | null;
+    constructor(props: IEditorPreviewProps);
+    render(): ReactNode;
+    /**
+     * Sets whether or not to render the scene.
+     * @param render defines whether or not to render the scene.
+     */
+    setRenderScene(render: boolean): void;
+    /**
+     * Resizes the engine.
+     */
+    resize(): void;
+    /**
+     * Resets the preview component by re-creating the engine and an empty scene.
+     */
+    reset(): Promise<void>;
+    /**
+     * Sets the fixed dimensions of the renderer. This is particularly useful to test the rendering
+     * performances and the aspect ratio of the scene in case it'll be renderer in fullscreen.
+     */
+    setFixedDimensions(fixedDimensions: "720p" | "1080p" | "4k" | "fit"): void;
+    /**
+     * Tries to focused the given object or the first one selected in the graph.
+     */
+    focusObject(object?: any): void;
+    /**
+     * Sets the given camera active as a preview.
+     * This helps to visualize what the selected camera sees when being manipulated
+     * using gizmos for example.
+     * When "null", the preview is removed.
+     * @param camera the camera to activate the preview
+     */
+    setCameraPreviewActive(camera: Camera | null): void;
+    private _onGotIconsRef;
+    private _onGotCanvasRef;
+    private _createWebgpuEngine;
+    /** @internal */
+    _handleMouseLeave(): void;
+    private _mouseMoveTimeoutId;
+    private _handleMouseMove;
+    private _handleMouseDown;
+    private _handleDoubleClick;
+    private _handleMouseUp;
+    private _getPickingInfo;
+    private _resetPointerContextInfo;
+    private _highlightCurrentMeshUnderPointer;
+    private _restoreCurrentMeshUnderPointer;
+    private _getToolbar;
+    private _getEditToolbar;
+    private _switchToCamera;
+    /**
+     * Sets the currently active gizmo. Set "none" to deactivate the gizmo.
+     * @param gizmo defines the type of gizmo to activate.
+     */
+    setActiveGizmo(gizmo: "position" | "rotation" | "scaling" | "none"): void;
+    importSceneFile(absolutePath: string, useCloudConverter: boolean): Promise<ISceneLoaderAsyncResult | null>;
+    private _handleDrop;
+    private _handleGraphNodesDropped;
+    private _handleSpritesDropped;
+    private _handleAssetsDropped;
+}