babylonjs-editor 4.5.0 → 5.4.0-alpha.2

package/declaration/src/loader/types.d.ts

@@ -0,0 +1,64 @@
+import { AssetContainer, PBRMaterial, Scene, VertexData } from "babylonjs";
+export type AssimpJSRuntime = {
+    data: IAssimpJSRootData;
+    scene: Scene;
+    rootUrl: string;
+    container: AssetContainer;
+    geometries: Record<number, VertexData>;
+    materials: Record<number, PBRMaterial>;
+};
+export interface IAssimpJSNodeData {
+    name: string;
+    meshes?: number[];
+    transformation: number[];
+    children?: IAssimpJSNodeData[];
+}
+export interface IAssimpJSBoneData {
+    name: string;
+    offsetmatrix: number[];
+    weights: [number, number][];
+}
+export interface IAssimpJSMeshData {
+    vertices: number[];
+    faces: number[][];
+    materialindex?: number;
+    name?: string;
+    normals?: number[];
+    texturecoords?: number[][];
+    bones?: IAssimpJSBoneData[];
+}
+export interface IAssimpJSMaterialData {
+    properties: IAssimpJSMaterialPropertyData[];
+}
+export interface IAssimpJSMaterialPropertyData {
+    key: string;
+    type: number;
+    index: number;
+    semantic: number;
+    value: string | number | number[];
+}
+export interface IAssimpJSTextureData {
+    data: unknown;
+    formathint: string;
+}
+export interface IAssimpJSAnimationChannelData {
+    name: string;
+    scalingkeys: [number, number[]][];
+    rotationkeys: [number, number[]][];
+    positionkeys: [number, number[]][];
+    poststate?: number;
+    prestate?: number;
+}
+export interface IAssimpJSAnimationData {
+    name: string;
+    duration: number;
+    tickspersecond: number;
+    channels: IAssimpJSAnimationChannelData[];
+}
+export interface IAssimpJSRootData {
+    meshes?: IAssimpJSMeshData[];
+    textures?: IAssimpJSTextureData[];
+    materials?: IAssimpJSMaterialData[];
+    animations?: IAssimpJSAnimationData[];
+    rootnode: IAssimpJSNodeData;
+}

package/declaration/src/project/add/camera.d.ts

@@ -0,0 +1,4 @@
+import { ArcRotateCamera, FreeCamera, Node } from "babylonjs";
+import { Editor } from "../../editor/main";
+export declare function addFreeCamera(editor: Editor, parent?: Node): FreeCamera;
+export declare function addArcRotateCamera(editor: Editor, parent?: Node): ArcRotateCamera;

package/declaration/src/project/add/configure.d.ts

@@ -0,0 +1,3 @@
+import { AbstractMesh, Node } from "babylonjs";
+import { Editor } from "../../editor/main";
+export declare function configureAddedMesh(editor: Editor, mesh: AbstractMesh, parent?: Node): AbstractMesh;

package/declaration/src/project/add/light.d.ts

@@ -0,0 +1,6 @@
+import { DirectionalLight, HemisphericLight, Node, PointLight, SpotLight } from "babylonjs";
+import { Editor } from "../../editor/main";
+export declare function addPointLight(editor: Editor, parent?: Node): PointLight;
+export declare function addDirectionalLight(editor: Editor, parent?: Node): DirectionalLight;
+export declare function addSpotLight(editor: Editor, parent?: Node): SpotLight;
+export declare function addHemisphericLight(editor: Editor, parent?: Node): HemisphericLight;

package/declaration/src/project/add/material.d.ts

@@ -0,0 +1,14 @@
+import { Scene, PBRMaterial, StandardMaterial, NodeMaterial } from "babylonjs";
+import { SkyMaterial, GridMaterial, NormalMaterial, WaterMaterial, LavaMaterial, TriPlanarMaterial, CellMaterial, FireMaterial, GradientMaterial } from "babylonjs-materials";
+export declare function addPBRMaterial(scene: Scene): PBRMaterial;
+export declare function addStandardMaterial(scene: Scene): StandardMaterial;
+export declare function addNodeMaterial(scene: Scene): NodeMaterial;
+export declare function addSkyMaterial(scene: Scene): SkyMaterial;
+export declare function addGridMaterial(scene: Scene): GridMaterial;
+export declare function addNormalMaterial(scene: Scene): NormalMaterial;
+export declare function addWaterMaterial(scene: Scene): WaterMaterial;
+export declare function addLavaMaterial(scene: Scene): LavaMaterial;
+export declare function addTriPlanarMaterial(scene: Scene): TriPlanarMaterial;
+export declare function addCellMaterial(scene: Scene): CellMaterial;
+export declare function addFireMaterial(scene: Scene): FireMaterial;
+export declare function addGradientMaterial(scene: Scene): GradientMaterial;

package/declaration/src/project/add/mesh.d.ts

@@ -0,0 +1,12 @@
+import { Node } from "babylonjs";
+import { Editor } from "../../editor/main";
+export declare function addBoxMesh(editor: Editor, parent?: Node): import("babylonjs").AbstractMesh;
+export declare function addPlaneMesh(editor: Editor, parent?: Node): import("babylonjs").AbstractMesh;
+export declare function addGroundMesh(editor: Editor, parent?: Node): import("babylonjs").AbstractMesh;
+export declare function addSphereMesh(editor: Editor, parent?: Node): import("babylonjs").AbstractMesh;
+export declare function addCapsuleMesh(editor: Editor, parent?: Node): import("babylonjs").AbstractMesh;
+export declare function addTorusMesh(editor: Editor, parent?: Node): import("babylonjs").AbstractMesh;
+export declare function addTorusKnotMesh(editor: Editor, parent?: Node): import("babylonjs").AbstractMesh;
+export declare function addCylinderMesh(editor: Editor, parent?: Node): import("babylonjs").AbstractMesh;
+export declare function addSkyboxMesh(editor: Editor, parent?: Node): import("babylonjs").AbstractMesh;
+export declare function addEmptyMesh(editor: Editor, parent?: Node): import("babylonjs").AbstractMesh;

package/declaration/src/project/add/node.d.ts

@@ -0,0 +1,3 @@
+import { Node } from "babylonjs";
+import { Editor } from "../../editor/main";
+export declare function addTransformNode(editor: Editor, parent?: Node): void;

package/declaration/src/project/add/particles.d.ts

@@ -0,0 +1,4 @@
+import { AbstractMesh } from "babylonjs";
+import { Editor } from "../../editor/main";
+export declare function addParticleSystem(editor: Editor, emitter: AbstractMesh): void;
+export declare function addGPUParticleSystem(editor: Editor, emitter: AbstractMesh): void;

package/declaration/src/project/add/sprite.d.ts

@@ -0,0 +1,6 @@
+import { Node } from "babylonjs";
+import { Editor } from "../../editor/main";
+import { SpriteMapNode } from "../../editor/nodes/sprite-map";
+import { SpriteManagerNode } from "../../editor/nodes/sprite-manager";
+export declare function addSpriteManager(editor: Editor, parent?: Node): SpriteManagerNode;
+export declare function addSpriteMapNode(editor: Editor, parent?: Node): SpriteMapNode;

package/declaration/src/project/configuration.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from "babylonjs";
+export interface IProjectConfiguration {
+    path: string | null;
+    compressedTexturesEnabled: boolean;
+}
+export declare const projectConfiguration: IProjectConfiguration;
+export declare const onProjectConfigurationChangedObservable: Observable<IProjectConfiguration>;
+/**
+ * Returns the rootUrl for assets for the current project.
+ */
+export declare function getProjectAssetsRootUrl(): string | null;

package/declaration/src/project/export/assets.d.ts

@@ -0,0 +1,9 @@
+import { Editor } from "../../editor/main";
+export type ProcessFileOptions = {
+    optimize: boolean;
+    scenePath: string;
+    projectDir: string;
+    exportedAssets: string[];
+    cache: Record<string, string>;
+};
+export declare function processAssetFile(editor: Editor, file: string, options: ProcessFileOptions): Promise<void>;

package/declaration/src/project/export/dialog.d.ts

@@ -0,0 +1,23 @@
+import { Component, ReactNode } from "react";
+import { Root } from "react-dom/client";
+import { Editor } from "../../editor/main";
+export declare function showExportSceneProgressDialog(editor: Editor, name: string): Promise<ExportSceneProgressComponent>;
+export interface IExportSceneProgressComponentProps {
+    name: string;
+    editor: Editor;
+    root: Root;
+    container: HTMLDivElement;
+}
+export interface IExportSceneProgressComponentState {
+    name: string;
+    progress: number;
+}
+export declare class ExportSceneProgressComponent extends Component<IExportSceneProgressComponentProps, IExportSceneProgressComponentState> {
+    private _step;
+    constructor(props: IExportSceneProgressComponentProps);
+    render(): ReactNode;
+    componentDidMount(): void;
+    step(step: number): void;
+    setName(name: string): void;
+    dispose(): void;
+}

package/declaration/src/project/export/export.d.ts

@@ -0,0 +1,7 @@
+import { Editor } from "../../editor/main";
+export type IExportProjectOptions = {
+    optimize: boolean;
+    noDialog?: boolean;
+    noProgress?: boolean;
+};
+export declare function exportProject(editor: Editor, options: IExportProjectOptions): Promise<void>;

package/declaration/src/project/export/ktx.d.ts

@@ -0,0 +1,29 @@
+import { Editor } from "../../editor/main";
+export type KTXToolsType = "-astc.ktx" | "-dxt.ktx" | "-pvrtc.ktx" | "-etc1.ktx" | "-etc2.ktx";
+export declare const allKtxFormats: KTXToolsType[];
+export declare const ktxSupportedextensions: string[];
+/**
+ * Returns the absolute path to the compressed textures CLI path (PVRTexTool).
+ * The value is retrieved from the local storage so it's per computer and not per project.
+ */
+export declare function getCompressedTexturesCliPath(): string | null;
+/**
+ * Sets the absolute path to the compressed textures CLI path (PVRTexTool).
+ * The value is stored in the local storage so it's per computer and not per project.
+ */
+export declare function setCompressedTexturesCliPath(absolutePath: string): void;
+/**
+ * Returns the filename of the compressed texture according to the given path and the destination format.
+ * @param path defines the path of the texture to get its final name.
+ * @param format defines the destination format of the texture.
+ * @example image.png -> image-asct.ktx
+ */
+export declare function getCompressedTextureFilename(path: string, format: KTXToolsType): string;
+export type CompressFileToKtxOptions = {
+    format: KTXToolsType;
+    force?: boolean;
+    exportedAssets?: string[];
+    destinationFolder?: string;
+};
+export declare function compressFileToKtx(editor: Editor, absolutePath: string, options: Partial<CompressFileToKtxOptions>): Promise<void>;
+export declare function compressFileToKtxFormat(editor: Editor, absolutePath: string, options: CompressFileToKtxOptions): Promise<string | null>;

package/declaration/src/project/export/lod.d.ts

@@ -0,0 +1,7 @@
+import { Scene } from "babylonjs";
+/**
+ * Configures the given data from scene serializer to support LOD meshes.
+ * @param data defines the JSON data coming from the scene serializer.
+ * @param scene defines the scene that contains the source meshes.
+ */
+export declare function configureMeshesLODs(data: any, scene: Scene): void;

package/declaration/src/project/export/materials.d.ts

@@ -0,0 +1,8 @@
+import { Editor } from "../../editor/main";
+export declare function configureMaterials(data: any): void;
+export type ProcessExportedMaterialOptions = {
+    force: boolean;
+    scenePath: string;
+    exportedAssets: string[];
+};
+export declare function processExportedMaterial(editor: Editor, absolutePath: string, options: ProcessExportedMaterialOptions): Promise<void>;

package/declaration/src/project/export/particles.d.ts

@@ -0,0 +1,9 @@
+import { Scene } from "babylonjs";
+import { Editor } from "../../editor/main";
+export declare function configureParticleSystems(data: any, scene: Scene): void;
+export type ProcessExportedParticleSystemOptions = {
+    force: boolean;
+    scenePath: string;
+    exportedAssets: string[];
+};
+export declare function processExportedNodeParticleSystemSet(editor: Editor, absolutePath: string, options: ProcessExportedParticleSystemOptions): Promise<void>;

package/declaration/src/project/export/physics.d.ts

@@ -0,0 +1,7 @@
+import { Scene } from "babylonjs";
+/**
+ * Configures the given data from scene serializer to support physics.
+ * @param data defines the JSON data coming from the scene serializer.
+ * @param scene defines the scene that contains the source meshes.
+ */
+export declare function configureMeshesPhysics(data: any, scene: Scene): void;

package/declaration/src/project/export/progress.d.ts

@@ -0,0 +1,11 @@
+import { Component, ReactNode } from "react";
+export interface IEditorExportProjectProgressComponentState {
+    progress: number;
+}
+export declare class EditorExportProjectProgressComponent extends Component<{}, IEditorExportProjectProgressComponentState> {
+    private _step;
+    constructor(props: {});
+    render(): ReactNode;
+    componentWillUnmount(): void;
+    step(step: number): void;
+}

package/declaration/src/project/export/scripts.d.ts

@@ -0,0 +1,2 @@
+import { Editor } from "../../editor/main";
+export declare function handleExportScripts(editor: Editor): Promise<void>;

package/declaration/src/project/export/texture.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from "../../editor/main";
+export type ComputeExportedTextureOptions = {
+    force: boolean;
+    exportedAssets: string[];
+};
+export declare function processExportedTexture(editor: Editor, absolutePath: string, options: ComputeExportedTextureOptions): Promise<void>;

package/declaration/src/project/load/default.d.ts

@@ -0,0 +1,3 @@
+import { Editor } from "../../editor/main";
+import { SceneLoadResult } from "./scene";
+export declare function createNewSceneDefaultNodes(editor: Editor, result: SceneLoadResult): void;

package/declaration/src/project/load/install.d.ts

@@ -0,0 +1,23 @@
+import { EditorProjectPackageManager } from "../typings";
+/**
+ * Install the dependencies of the project located at the given working directory.
+ * @param packageManager defines the package manager to use for installation.
+ * @param cwd defines absolute path to the working directory where to install the dependencies.
+ */
+export declare function installDependencies(packageManager: EditorProjectPackageManager, cwd: string): Promise<number>;
+/**
+ * Installs the babylonjs-editor-tools package that matches the given version.
+ * The given version is mostly the current version of the editor.
+ * @param packageManager defines the package manager to use for installation.
+ * @param cwd defines absolute path to the working directory where to install the dependencies.
+ * @param version defines the version of babylonjs-editor-tools to install.
+ */
+export declare function installBabylonJSEditorTools(packageManager: EditorProjectPackageManager, cwd: string, version: string): Promise<number>;
+/**
+ * Installs the babylonjs-editor-cli package that matches the given version.
+ * The given version is mostly the current version of the editor.
+ * @param packageManager defines the package manager to use for installation.
+ * @param cwd defines absolute path to the working directory where to install the dependencies.
+ * @param version defines the version of babylonjs-editor-cli to install.
+ */
+export declare function installBabylonJSEditorCLI(packageManager: EditorProjectPackageManager, cwd: string, version: string): Promise<number>;

package/declaration/src/project/load/load.d.ts

@@ -0,0 +1,16 @@
+import { Editor } from "../../editor/main";
+import { EditorProjectPackageManager, IEditorProject } from "../typings";
+/**
+ * Loads an editor project located at the given path. Typically called at startup when opening
+ * a project from the dashboard.
+ * @param editor defines the reference to the editor.
+ * @param path defines the absolute path to the project file.
+ */
+export declare function loadProject(editor: Editor, path: string): Promise<void>;
+export declare function checkDependencies(editor: Editor, { directory, path, project, packageManager, }: {
+    directory: string;
+    path: string;
+    project: IEditorProject;
+    packageManager: EditorProjectPackageManager;
+}): Promise<void>;
+export declare function loadProjectPlugins(editor: Editor, path: string, project: IEditorProject): Promise<void>;

package/declaration/src/project/load/plugins/animation-groups.d.ts

@@ -0,0 +1,4 @@
+import { Scene } from "babylonjs";
+import { Editor } from "../../../editor/main";
+import { ISceneLoaderPluginOptions } from "../scene";
+export declare function loadAnimationGroups(editor: Editor, animationGroupFiles: string[], scene: Scene, options: ISceneLoaderPluginOptions): Promise<void>;

package/declaration/src/project/load/plugins/cameras.d.ts

@@ -0,0 +1,4 @@
+import { Scene } from "babylonjs";
+import { Editor } from "../../../editor/main";
+import { ISceneLoaderPluginOptions } from "../scene";
+export declare function loadCameras(editor: Editor, cameraFiles: string[], scene: Scene, options: ISceneLoaderPluginOptions): Promise<void>;

package/declaration/src/project/load/plugins/gui.d.ts

@@ -0,0 +1,3 @@
+import { Editor } from "../../../editor/main";
+import { ISceneLoaderPluginOptions } from "../scene";
+export declare function loadGuis(editor: Editor, guiFiles: string[], options: ISceneLoaderPluginOptions): Promise<void>;

package/declaration/src/project/load/plugins/lights.d.ts

@@ -0,0 +1,4 @@
+import { Scene } from "babylonjs";
+import { Editor } from "../../../editor/main";
+import { ISceneLoaderPluginOptions } from "../scene";
+export declare function loadLights(editor: Editor, lightsFiles: string[], scene: Scene, options: ISceneLoaderPluginOptions): Promise<void>;

package/declaration/src/project/load/plugins/meshes.d.ts

@@ -0,0 +1,3 @@
+import { Scene } from "babylonjs";
+import { ISceneLoaderPluginOptions } from "../scene";
+export declare function loadMeshes(meshesFiles: string[], scene: Scene, options: ISceneLoaderPluginOptions): Promise<void>;

package/declaration/src/project/load/plugins/morph-targets.d.ts

@@ -0,0 +1,4 @@
+import { Scene } from "babylonjs";
+import { Editor } from "../../../editor/main";
+import { ISceneLoaderPluginOptions } from "../scene";
+export declare function loadMorphTargetManagers(editor: Editor, morphTargetManagerFiles: string[], scene: Scene, options: ISceneLoaderPluginOptions): Promise<void>;

package/declaration/src/project/load/plugins/node-particle-system-sets.d.ts

@@ -0,0 +1,4 @@
+import { Scene } from "babylonjs";
+import { Editor } from "../../../editor/main";
+import { ISceneLoaderPluginOptions } from "../scene";
+export declare function loadNodeParticleSystemSets(editor: Editor, nodeParticleSystemSetFiles: string[], scene: Scene, options: ISceneLoaderPluginOptions): Promise<void>;

package/declaration/src/project/load/plugins/particle-systems.d.ts

@@ -0,0 +1,4 @@
+import { Scene } from "babylonjs";
+import { Editor } from "../../../editor/main";
+import { ISceneLoaderPluginOptions } from "../scene";
+export declare function loadParticleSystems(editor: Editor, particleSystemFiles: string[], scene: Scene, options: ISceneLoaderPluginOptions): Promise<void>;

package/declaration/src/project/load/plugins/shadow-generators.d.ts

@@ -0,0 +1,4 @@
+import { Scene } from "babylonjs";
+import { Editor } from "../../../editor/main";
+import { ISceneLoaderPluginOptions } from "../scene";
+export declare function loadShadowGenerators(editor: Editor, shadowGeneratorFiles: string[], scene: Scene, options: ISceneLoaderPluginOptions): Promise<void>;

package/declaration/src/project/load/plugins/skeletons.d.ts

@@ -0,0 +1,4 @@
+import { Scene } from "babylonjs";
+import { Editor } from "../../../editor/main";
+import { ISceneLoaderPluginOptions } from "../scene";
+export declare function loadSkeletons(editor: Editor, skeletonFiles: string[], scene: Scene, options: ISceneLoaderPluginOptions): Promise<void>;

package/declaration/src/project/load/plugins/sounds.d.ts

@@ -0,0 +1,4 @@
+import { Scene } from "babylonjs";
+import { Editor } from "../../../editor/main";
+import { ISceneLoaderPluginOptions } from "../scene";
+export declare function loadSounds(editor: Editor, soundFiles: string[], scene: Scene, options: ISceneLoaderPluginOptions): Promise<void>;

package/declaration/src/project/load/plugins/sprite-managers.d.ts

@@ -0,0 +1,4 @@
+import { Scene } from "babylonjs";
+import { Editor } from "../../../editor/main";
+import { ISceneLoaderPluginOptions } from "../scene";
+export declare function loadSpriteManagers(editor: Editor, spriteManagerFiles: string[], scene: Scene, options: ISceneLoaderPluginOptions): Promise<void>;

package/declaration/src/project/load/plugins/sprite-maps.d.ts

@@ -0,0 +1,4 @@
+import { Scene } from "babylonjs";
+import { Editor } from "../../../editor/main";
+import { ISceneLoaderPluginOptions } from "../scene";
+export declare function loadSpriteMaps(editor: Editor, spriteMapFiles: string[], scene: Scene, options: ISceneLoaderPluginOptions): Promise<void>;

package/declaration/src/project/load/plugins/transform-nodes.d.ts

@@ -0,0 +1,4 @@
+import { Scene } from "babylonjs";
+import { Editor } from "../../../editor/main";
+import { ISceneLoaderPluginOptions } from "../scene";
+export declare function loadTransformNodes(editor: Editor, nodesFiles: string[], scene: Scene, options: ISceneLoaderPluginOptions): Promise<void>;

package/declaration/src/project/load/prepare.d.ts

@@ -0,0 +1,4 @@
+import { Component, ReactNode } from "react";
+export declare class LoadScenePrepareComponent extends Component {
+    render(): ReactNode;
+}

package/declaration/src/project/load/progress.d.ts

@@ -0,0 +1,20 @@
+import { Component, ReactNode } from "react";
+import { Root } from "react-dom/client";
+export declare function showLoadSceneProgressDialog(name: string): Promise<LoadSceneProgressComponent>;
+export interface ILoadSceneProgressComponentProps {
+    name: string;
+    root: Root;
+    container: HTMLDivElement;
+}
+export interface ILoadSceneProgressComponentState {
+    name: string;
+    progress: number;
+}
+export declare class LoadSceneProgressComponent extends Component<ILoadSceneProgressComponentProps, ILoadSceneProgressComponentState> {
+    private _step;
+    constructor(props: ILoadSceneProgressComponentProps);
+    render(): ReactNode;
+    step(step: number): void;
+    setName(name: string): void;
+    dispose(): void;
+}

package/declaration/src/project/load/scene.d.ts

@@ -0,0 +1,34 @@
+import { AbstractMesh, AnimationGroup, Camera, Light, TransformNode, IParticleSystem } from "babylonjs";
+import { Editor } from "../../editor/main";
+import { SceneLinkNode } from "../../editor/nodes/scene-link";
+import { SpriteMapNode } from "../../editor/nodes/sprite-map";
+import { SpriteManagerNode } from "../../editor/nodes/sprite-manager";
+import { IAssetCache } from "../../tools/assets/cache";
+import { LoadSceneProgressComponent } from "./progress";
+export type SceneLoaderOptions = {
+    /**
+     * Defines wether or not the scene is being loaded as link.
+     */
+    asLink?: boolean;
+};
+export type SceneLoadResult = {
+    lights: Light[];
+    cameras: Camera[];
+    meshes: AbstractMesh[];
+    sceneLinks: SceneLinkNode[];
+    transformNodes: TransformNode[];
+    animationGroups: AnimationGroup[];
+    particleSystems: IParticleSystem[];
+    spriteMaps: SpriteMapNode[];
+    spriteManagers: SpriteManagerNode[];
+};
+export type ISceneLoaderPluginOptions = SceneLoaderOptions & {
+    scenePath: string;
+    relativeScenePath: string;
+    projectPath: string;
+    loadResult: SceneLoadResult;
+    progress: LoadSceneProgressComponent;
+    progressStep: number;
+    assetsCache: Record<string, IAssetCache>;
+};
+export declare function loadScene(editor: Editor, projectPath: string, scenePath: string, options?: SceneLoaderOptions): Promise<SceneLoadResult>;

package/declaration/src/project/load/texture.d.ts

@@ -0,0 +1,2 @@
+import { Editor } from "../../editor/main";
+export declare function registerTextureParser(editor: Editor): void;

package/declaration/src/project/run.d.ts

@@ -0,0 +1,3 @@
+import { Editor } from "../editor/main";
+export declare function startProjectDevProcess(editor: Editor): Promise<void>;
+export declare function stopProjectDevProcess(): Promise<void>;

package/declaration/src/project/save/dialog.d.ts

@@ -0,0 +1,23 @@
+import { Component, ReactNode } from "react";
+import { Root } from "react-dom/client";
+import { Editor } from "../../editor/main";
+export declare function showSaveSceneProgressDialog(editor: Editor, name: string): Promise<SaveSceneProgressComponent>;
+export interface ISaveSceneProgressComponentProps {
+    name: string;
+    editor: Editor;
+    root: Root;
+    container: HTMLDivElement;
+}
+export interface ISaveSceneProgressComponentState {
+    name: string;
+    progress: number;
+}
+export declare class SaveSceneProgressComponent extends Component<ISaveSceneProgressComponentProps, ISaveSceneProgressComponentState> {
+    private _step;
+    constructor(props: ISaveSceneProgressComponentProps);
+    render(): ReactNode;
+    componentDidMount(): void;
+    step(step: number): void;
+    setName(name: string): void;
+    dispose(): void;
+}

package/declaration/src/project/save/progress.d.ts

@@ -0,0 +1,4 @@
+import { Component, ReactNode } from "react";
+export declare class EditorSaveProjectProgressComponent extends Component {
+    render(): ReactNode;
+}

package/declaration/src/project/save/save.d.ts

@@ -0,0 +1,4 @@
+import { Editor } from "../../editor/main";
+import { IEditorProject } from "../typings";
+export declare function saveProject(editor: Editor): Promise<void>;
+export declare function saveProjectConfiguration(editor: Editor): Promise<Partial<IEditorProject>>;

package/declaration/src/project/save/scene.d.ts

@@ -0,0 +1,2 @@
+import { Editor } from "../../editor/main";
+export declare function saveScene(editor: Editor, projectPath: string, scenePath: string): Promise<void>;

package/declaration/src/project/tools/geometry.d.ts

@@ -0,0 +1,7 @@
+export interface IWriteBinaryGeometryOptions {
+    path: string;
+    geometry: any;
+    mesh: any;
+    write: boolean;
+}
+export declare function writeBinaryGeometry(options: IWriteBinaryGeometryOptions): Promise<void>;

package/declaration/src/project/tools/morph-target.d.ts

@@ -0,0 +1 @@
+export declare function writeBinaryMorphTarget(path: string, morphTarget: any): Promise<void>;

package/declaration/src/project/typings.d.ts

@@ -0,0 +1,34 @@
+export interface IEditorProject {
+    /**
+     * The version of the editor that saved this project.
+     */
+    version: string;
+    /**
+     * The path to the last opened scene.
+     */
+    lastOpenedScene: string | null;
+    /**
+     * The plugins of the project.
+     */
+    plugins: IEditorProjectPlugin[];
+    /**
+     * If the compressed textures are enabled using PVRTexTool.
+     */
+    compressedTexturesEnabled: boolean;
+    /**
+     * If the compressed textures are enabled in the preview.
+     */
+    compressedTexturesEnabledInPreview: boolean;
+    /**
+     * The package manager being used by the project.
+     */
+    packageManager?: EditorProjectPackageManager;
+}
+export interface IEditorProjectPlugin {
+    /**
+     * The name or path of the plugin.
+     */
+    nameOrPath: string;
+}
+export type EditorProjectPackageManager = "npm" | "yarn" | "pnpm" | "bun";
+export type EditorProjectTemplate = "nextjs" | "solidjs" | "vanillajs" | "electron";

package/declaration/src/splash/main.d.ts

@@ -0,0 +1,6 @@
+import { Component, ReactNode } from "react";
+export declare function createSplash(): void;
+export declare class Splash extends Component {
+    constructor();
+    render(): ReactNode;
+}

package/declaration/src/tools/animation/group.d.ts

@@ -0,0 +1,7 @@
+import { Scene, AnimationGroup, TargetedAnimation } from "babylonjs";
+/**
+ * Gets a new map containing for each animation group the targeted animations that are linked to the given targets.
+ * @param targets defines the array of targets to check for linked animations (meshes, transform nodes, etc.).
+ * @param scene defines the reference to the scene to check for animation groups.
+ */
+export declare function getLinkedAnimationGroupsFor(targets: any[], scene: Scene): Map<AnimationGroup, TargetedAnimation[]>;

package/declaration/src/tools/animation/tools.d.ts

@@ -0,0 +1,27 @@
+import { Tween } from "./tween";
+/**
+ * Defines the reference to the map that contains, for each target object, a list of tweens.
+ */
+export declare const tweensMap: Map<any, Tween[]>;
+/**
+ * Registers the given target object that is being animated by tweens.
+ * @param target defines the reference to the target object to register.
+ */
+export declare function registerTarget<T>(target: T): void;
+/**
+ * Registers the given tween that animates the given target.
+ * @param target defines the reference to the animated target object.
+ * @param tween defines the reference to the tween to register that animates the given target object.
+ */
+export declare function registerTween<T>(target: T, tween: Tween): void;
+/**
+ * Checks for the given target to delete or keep active tweens array from the cache.
+ * @param target defines the reference to the target to check its attached tweens.
+ */
+export declare function checkTargetTweens<T>(target: T): void;
+/**
+ * Removes the given tween from the attached tweens of the given target object once the tween ended.
+ * @param target defines the reference to the target to check its array of tweens.
+ * @param tween defines the reference to the tween to check its "ended" event.
+ */
+export declare function registerTweenEnded<T>(target: T, tween: Tween): void;