babylonjs-editor 4.5.0 → 5.4.0-alpha.2

package/declaration/src/tools/marketplaces/types.d.ts

@@ -0,0 +1,79 @@
+export interface IDownloadOptions {
+    [quality: string]: {
+        [fileType: string]: {
+            include: {
+                [path: string]: {
+                    size: number;
+                    url: string;
+                    md5: string;
+                };
+            };
+            size: number;
+            url: string;
+            md5: string;
+            extension?: string;
+        };
+    };
+}
+export interface IMarketplaceAsset {
+    id: string;
+    name: string;
+    thumbnailUrl: string;
+    description?: string;
+    author?: string;
+    license?: string;
+    tags?: string[];
+    marketplaceUrl?: string;
+    marketplaceActionLabel?: string;
+    isDownloadable?: boolean;
+    downloadOptions?: IDownloadOptions;
+}
+export interface IMarketplaceSearchResult {
+    assets: IMarketplaceAsset[];
+    totalCount?: number;
+    nextPageToken?: string;
+}
+export type MarketplaceFilterValue = string | number | boolean | string[];
+export interface IMarketplaceFilterOption {
+    label: string;
+    value: string;
+}
+export interface IMarketplaceFilterDefinition {
+    id: string;
+    label: string;
+    type: "boolean" | "select" | "multi-select" | "number" | "text";
+    options?: IMarketplaceFilterOption[];
+    defaultValue?: MarketplaceFilterValue;
+    placeholder?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+export interface IMarketplaceSearchFilters {
+    [id: string]: MarketplaceFilterValue | undefined;
+}
+export interface IFileToDownload {
+    url: string;
+    path: string;
+    size?: number;
+    md5?: string;
+    extract?: boolean;
+}
+export interface IMarketplaceProgress {
+    progress?: number;
+    loaded?: number;
+    total?: number;
+    speed?: number;
+    extraStatus?: string;
+}
+export interface IMarketplaceOAuth {
+    authorizeUrl: string;
+    redirectUrl: string;
+    onRedirect(url: string): Promise<void>;
+}
+export interface IMarketplaceSettings {
+}
+export interface IMarketplaceDownloadItem {
+    id: string;
+    abortController: AbortController;
+}

package/declaration/src/tools/material/extract.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from "../../editor/main";
+export interface IExtractNodeMaterialTexturesOptions {
+    materialData: any;
+    assetsDirectory: string;
+}
+export declare function extractNodeMaterialTextures(editor: Editor, options: IExtractNodeMaterialTexturesOptions): Promise<string[]>;

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

@@ -0,0 +1,11 @@
+import { Material, NodeMaterial } from "babylonjs";
+/**
+ * Configures the given material to receive up to 32 lights simultaneously.
+ * @param material defines the reference to the material to configure.
+ */
+export declare function configureSimultaneousLightsForMaterial(material: Material): void;
+/**
+ * Normalizes the unique IDs of the nodes in the given Node Material based on the provided material data.
+ * This allows to get ids not modified after reloading the material to be git-compliant.
+ */
+export declare function normalizeNodeMaterialUniqueIds(material: NodeMaterial, materialData: any): void;

package/declaration/src/tools/material/texture.d.ts

@@ -0,0 +1,2 @@
+import { Scene } from "babylonjs";
+export declare function storeTexturesBaseSize(scene: Scene): void;

package/declaration/src/tools/maths/projection.d.ts

@@ -0,0 +1,2 @@
+import { Scene, Vector2, Vector3 } from "babylonjs";
+export declare function projectVectorOnScreen(vector: Vector3, scene: Scene): Vector2;

package/declaration/src/tools/maths/scalar.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns the power of two sizes until the given limit.
+ * @param limit The limit size.
+ * @param from The starting size. Default is 1.
+ * @returns An array of power of two sizes.
+ */
+export declare function getPowerOfTwoSizesUntil(limit?: number, from?: number): number[];
+export declare function getPowerOfTwoUntil(limit: number): number;

package/declaration/src/tools/mesh/augmentations.d.ts

@@ -0,0 +1,7 @@
+import { PhysicsAggregate } from "babylonjs";
+export { AbstractMesh } from "babylonjs";
+declare module "babylonjs" {
+    interface AbstractMesh {
+        physicsAggregate?: PhysicsAggregate | null;
+    }
+}

package/declaration/src/tools/mesh/collision.d.ts

@@ -0,0 +1,7 @@
+import { Mesh } from "babylonjs";
+import { CollisionMesh } from "../../editor/nodes/collision";
+/**
+ * Looking for descendants of the given mesh, returns the reference to the first collision
+ * mesh found. A collision mesh is unique per mesh.
+ */
+export declare function getCollisionMeshFor(mesh: Mesh): CollisionMesh | null;

package/declaration/src/tools/mesh/ground.d.ts

@@ -0,0 +1,10 @@
+import { Mesh, FloatArray, IndicesArray } from "babylonjs";
+export interface ISmoothGroundGeometryOptions {
+    ground: Mesh;
+    smoothFactor: number;
+    subdivisions: number;
+    indices?: IndicesArray | null;
+    normals?: FloatArray | null;
+    positions?: FloatArray | null;
+}
+export declare function smoothGroundGeometry(options: ISmoothGroundGeometryOptions): void;

package/declaration/src/tools/mesh/instance.d.ts

@@ -0,0 +1,3 @@
+import { Mesh } from "babylonjs";
+import { Editor } from "../../editor/main";
+export declare function createMeshInstance(editor: Editor, mesh: Mesh): import("babylonjs").InstancedMesh;

package/declaration/src/tools/node/clone.d.ts

@@ -0,0 +1,10 @@
+import { Node, Sprite, ParticleSystem, GPUParticleSystem } from "babylonjs";
+import { Editor } from "../../editor/main";
+import { SpriteManagerNode } from "../../editor/nodes/sprite-manager";
+export interface ICloneNodeOptions {
+    shareGeometry?: boolean;
+    shareSkeleton?: boolean;
+    cloneMaterial?: boolean;
+    cloneThinInstances?: boolean;
+}
+export declare function cloneNode(editor: Editor, node: Node | Sprite | ParticleSystem | GPUParticleSystem, options?: ICloneNodeOptions): Node | SpriteManagerNode | Sprite | GPUParticleSystem | null;

package/declaration/src/tools/node/metadata.d.ts

@@ -0,0 +1,55 @@
+import { Node } from "babylonjs";
+export interface INodeMetadata {
+    /**
+     * Defines wether or not the object is locked.
+     */
+    isLocked?: boolean;
+    /**
+     * Defines wether or not the object should be serialized when the scene is exported.
+     */
+    doNotSerialize?: boolean;
+    /**
+     * Defines wether or not the object is visible in the graph panel in the editor.
+     */
+    notVisibleInGraph?: boolean;
+}
+/**
+ * Ensures that metadata exists for the given node.
+ * @param node defines the node to ensure metadata for.
+ * @returns the metadata of the node, creating it if does not exist.
+ */
+export declare function ensureNodeMetadata(node: Node): INodeMetadata;
+/**
+ * Gets wether or not the given node is locked in the editor.
+ * @param node defines the node to check.
+ * @returns true if the node is locked, false otherwise.
+ */
+export declare function isNodeLocked(node: Node): boolean;
+/**
+ * Sets wether or not the given node is locked in the editor.
+ * @param node defines the node to configure.
+ * @param locked defines the value to set.
+ */
+export declare function setNodeLocked(node: Node, locked: boolean): void;
+/**
+ * Gets wether or not the given node is not serializable.
+ * @param node defines the reference to the node to get the metadata to.
+ */
+export declare function isNodeSerializable(node: Node): boolean;
+/**
+ * Sets wether or not the given node is not serializable.
+ * @param node defines the reference to the node to set configuration.
+ * @param value defines the value to set.
+ */
+export declare function setNodeSerializable(node: Node, value: boolean): void;
+/**
+ * Gets wether or not the given node is visible in the graph panel of the editor.
+ * @param node defines the reference to the node to check.
+ */
+export declare function isNodeVisibleInGraph(node: Node): boolean;
+/**
+ * Sets wether or not the given node is visible in the graph panel of the editor.
+ * @param node defines the reference to the node to set configuration.
+ * @param value defines the value to set.
+ */
+export declare function setNodeVisibleInGraph(node: Node, value: boolean): void;

package/declaration/src/tools/node/parenting.d.ts

@@ -0,0 +1,11 @@
+import { Node, Vector3, Quaternion, TransformNode } from "babylonjs";
+export interface IOldNodeHierarchyConfiguration {
+    parent: Node | null;
+    position?: Vector3;
+    rotation?: Vector3;
+    scaling?: Vector3;
+    rotationQuaternion?: Quaternion;
+}
+export declare function getNodeParentingConfiguration(node: Node): IOldNodeHierarchyConfiguration;
+export declare function applyNodeParentingConfiguration(node: Node, config: IOldNodeHierarchyConfiguration): void;
+export declare function applyTransformNodeParentingConfiguration(node: Node, newParent: Node | null, tempTransfromNode: TransformNode): void;

package/declaration/src/tools/node-pty.d.ts

@@ -0,0 +1,43 @@
+import { IPtyForkOptions, IWindowsPtyForkOptions } from "node-pty";
+import { Observable } from "babylonjs";
+/**
+ * Creates a new node-pty instance.
+ * @param command The command to run in the pty process.
+ * @param options The options to pass to the pty process.
+ * @returns A promise that resolves with the node-pty instance.
+ */
+export declare function execNodePty(command: string, options?: IPtyForkOptions | IWindowsPtyForkOptions): Promise<NodePtyInstance>;
+export declare class NodePtyInstance {
+    /**
+     * The id of the node-pty instance.
+     */
+    readonly id: string;
+    /**
+     * An observable that is triggered when data is received from the pty.
+     */
+    onGetDataObservable: Observable<string>;
+    private _exited;
+    private _exitCode;
+    /**
+     * Constructor.
+     * @param id The id of the node-pty instance.
+     */
+    constructor(id: string);
+    /**
+     * Writes data to the pty.
+     * @param data The data to write.
+     */
+    write(data: string): void;
+    /**
+     * Kills the pty process.
+     */
+    kill(): void;
+    /**
+     * Waits until the
+     */
+    wait(): Promise<number>;
+    /**
+     * Resizes the node-pty process in case it is used using xterm.
+     */
+    resize(cols: number, rows: number): void;
+}

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

@@ -0,0 +1,45 @@
+import { BaseTexture, Node, Observable, IParticleSystem, Sprite, Skeleton } from "babylonjs";
+/**
+ * Observable for when the project has been saved.
+ */
+export declare const onProjectSavedObservable: Observable<void>;
+/**
+ * Observable for when new nodes have been added to the scene.
+ */
+export declare const onNodesAddedObservable: Observable<void>;
+/**
+ * Observable for when a node has been modified in the editor.
+ */
+export declare const onNodeModifiedObservable: Observable<Node>;
+/**
+ * Observable for when a skeleton has been modified in the editor.
+ */
+export declare const onSkeletonModifiedObservable: Observable<Skeleton>;
+/**
+ * Observable for when a sprite has been modified in the editor.
+ */
+export declare const onSpriteModifiedObservable: Observable<Sprite>;
+/**
+ * Observable for when new textures have been added to the scene.
+ */
+export declare const onTextureAddedObservable: Observable<BaseTexture>;
+/**
+ * Observable for when a texture has been modified in the editor.
+ */
+export declare const onTextureModifiedObservable: Observable<BaseTexture>;
+/**
+ * Observable for when new particle systems have been added to the scene.
+ */
+export declare const onParticleSystemAddedObservable: Observable<IParticleSystem>;
+/**
+ * Observable for when a particle system has been modified in the editor.
+ */
+export declare const onParticleSystemModifiedObservable: Observable<IParticleSystem>;
+/**
+ * Observable used for when the path browsed by "Assets Browser" has changed.
+ */
+export declare const onAssetsBrowsedPathChanged: Observable<string>;
+/**
+ * Observable used for when the selected asset in "Assets Browser" has changed.
+ */
+export declare const onSelectedAssetChanged: Observable<string>;

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

@@ -0,0 +1,10 @@
+/**
+ * Returns true if the current platform is macOS.
+ * @returns True if the current platform is macOS.
+ */
+export declare function isDarwin(): boolean;
+/**
+ * Returns true if the current platform is Windows.
+ * @returns True if the current platform is Windows.
+ */
+export declare function isWindows(): boolean;

package/declaration/src/tools/particles/augmentations.d.ts

@@ -0,0 +1,7 @@
+export { NodeParticleSystemSet } from "babylonjs";
+declare module "babylonjs" {
+    interface NodeParticleSystemSet {
+        id?: string;
+        uniqueId?: number;
+    }
+}

package/declaration/src/tools/particles/extract.d.ts

@@ -0,0 +1,10 @@
+import { Editor } from "../../editor/main";
+import { IExtractTextureAssetFromDataStringResult } from "../assets/extract";
+export interface IExtractParticleSystemTexturesOptions {
+    assetsDirectory: string;
+}
+export declare function extractParticleSystemTextures(editor: Editor, particleSystemData: any, options: IExtractParticleSystemTexturesOptions): Promise<IExtractTextureAssetFromDataStringResult | null>;
+export interface IExtractNodeParticleSystemSetTexturesOptions extends IExtractParticleSystemTexturesOptions {
+    particlesData: any;
+}
+export declare function extractNodeParticleSystemSetTextures(editor: Editor, options: IExtractNodeParticleSystemSetTexturesOptions): Promise<string[]>;

package/declaration/src/tools/particles/metadata.d.ts

@@ -0,0 +1,39 @@
+import { ParticleSystem, GPUParticleSystem } from "babylonjs";
+export interface IParticleSystemMetadata {
+    /**
+     * Defines wether or not the object should be serialized when the scene is exported.
+     */
+    doNotSerialize?: boolean;
+    /**
+     * Defines wether or not the object is visible in the graph panel in the editor.
+     */
+    notVisibleInGraph?: boolean;
+}
+/**
+ * Ensures that metadata exists for the given node.
+ * @param node defines the node to ensure metadata for.
+ * @returns the metadata of the node, creating it if does not exist.
+ */
+export declare function ensureParticleSystemMetadata(node: ParticleSystem | GPUParticleSystem): IParticleSystemMetadata;
+/**
+ * Gets wether or not the given node is not serializable.
+ * @param node defines the reference to the node to get the metadata to.
+ */
+export declare function isParticleSystemSerializable(node: ParticleSystem | GPUParticleSystem): boolean;
+/**
+ * Sets wether or not the given node is not serializable.
+ * @param node defines the reference to the node to set configuration.
+ * @param value defines the value to set.
+ */
+export declare function setParticleSystemSerializable(node: ParticleSystem | GPUParticleSystem, value: boolean): void;
+/**
+ * Gets wether or not the given node is visible in the graph panel of the editor.
+ * @param node defines the reference to the node to check.
+ */
+export declare function isParticleSystemVisibleInGraph(node: ParticleSystem | GPUParticleSystem): boolean;
+/**
+ * Sets wether or not the given node is visible in the graph panel of the editor.
+ * @param node defines the reference to the node to set configuration.
+ * @param value defines the value to set.
+ */
+export declare function setParticleSystemVisibleInGraph(node: ParticleSystem | GPUParticleSystem, value: boolean): void;

package/declaration/src/tools/particles/particle.d.ts

@@ -0,0 +1,6 @@
+import { NodeParticleSystemSet } from "babylonjs";
+/**
+ * Normalizes the unique IDs of the nodes in the given Node Particle System Set based on the provided node particle system set data.
+ * This allows to get ids not modified after reloading the node particle system set to be git-compliant.
+ */
+export declare function normalizeNodeParticleSystemSetUniqueIds(nodeParticleSystem: NodeParticleSystemSet, nodeParticleSystemSetData: any): void;

package/declaration/src/tools/particles/texture.d.ts

@@ -0,0 +1,8 @@
+import { RawTexture, Scene } from "babylonjs";
+/**
+ * Creates a raw texture composed of random values for RGBA in order to be used by GPU particle systems.
+ * This is useful in case the random textures of a GPU particle system must be changed dynamically.
+ * @param textureSize defines the size of the texture (size x size).
+ * @param scene defines the reference to the scene where to add the texture.
+ */
+export declare function createGpuParticleSystemRandomTexture(textureSize: number, scene: Scene): RawTexture;

package/declaration/src/tools/physics/init.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Initializes the Havok physics engine for being used in the Editor with Babylon.js.
+ * @param appPath defines the absolute path to the Editor application.
+ */
+export declare function initializeHavok(appPath: string): Promise<void>;

package/declaration/src/tools/physics/serialization/aggregate.d.ts

@@ -0,0 +1,33 @@
+import { TransformNode, PhysicsAggregate } from "babylonjs";
+/**
+ * Returns the JSON representation of the given physics aggregate.
+ * @param aggregate defines the reference to the physics aggregate object to serialize.
+ */
+export declare function serializePhysicsAggregate(aggregate: PhysicsAggregate): {
+    shape: {
+        type: import("babylonjs").PhysicsShapeType;
+        density: number;
+    };
+    body: {
+        motionType: import("babylonjs").PhysicsMotionType;
+    };
+    massProperties: {
+        mass: number | undefined;
+        inertia: [number, number, number] | undefined;
+        centerOfMass: [number, number, number] | undefined;
+        inertiaOrientation: [number, number, number, number] | undefined;
+    };
+    material: {
+        friction: number | undefined;
+        restitution: number | undefined;
+        staticFriction: number | undefined;
+        frictionCombine: import("babylonjs").PhysicsMaterialCombineMode | undefined;
+        restitutionCombine: import("babylonjs").PhysicsMaterialCombineMode | undefined;
+    };
+};
+/**
+ * Returns a new instance of PhysicsAggregate from the given JSON representation.
+ * @param transformNode defines the reference to the transform node to setup the physics aggregate.
+ * @param data defines the JSON representation of the physics aggregate to parse.
+ */
+export declare function parsePhysicsAggregate(transformNode: TransformNode, data: any): PhysicsAggregate;

package/declaration/src/tools/physics/shape.d.ts

@@ -0,0 +1,7 @@
+import { AbstractMesh, PhysicsShapeType } from "babylonjs";
+/**
+ * Returns the type of shape that should be applied by default for the given mesh.
+ * Will check its metadata and collisions to determine the best shape.
+ * @param mesh defines the reference to the mesh to check its nature and determine the physics shape.
+ */
+export declare function getPhysicsShapeForMesh(mesh: AbstractMesh): PhysicsShapeType;

package/declaration/src/tools/plugins/require.d.ts

@@ -0,0 +1,7 @@
+import { Editor } from "../../editor/main";
+export interface IRequirePluginOptions {
+    projectPath: string;
+    pluginNameOrPath: string;
+    noWatch?: boolean;
+}
+export declare function requirePlugin(editor: Editor, options: IRequirePluginOptions): Promise<void>;

package/declaration/src/tools/plugins/watch.d.ts

@@ -0,0 +1,5 @@
+import { FSWatcher } from "chokidar";
+import { Editor } from "../../editor/main";
+import { IRequirePluginOptions } from "./require";
+export declare const pluginWatchers: Map<string, FSWatcher>;
+export declare function watchPlugin(editor: Editor, requireId: string, options: IRequirePluginOptions): void;

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

@@ -0,0 +1,36 @@
+import { EditorProjectPackageManager } from "../project/typings";
+/**
+ * Get the file path argument from the command line arguments.
+ * @param argv The command line arguments.
+ * @returns The file path argument or null if none was found.
+ */
+export declare function getFilePathArgument(argv?: string[] | null): string | null;
+/**
+ * Executes the given command asynchronously using `child_process`
+ * @param command defines the command to execute.
+ */
+export declare function executeAsync(command: string): Promise<void>;
+export declare let nodeJSAvailable: boolean;
+export declare let packageManagerAvailable: boolean;
+export declare let visualStudioCodeAvailable: boolean;
+/**
+ * Checks wether or not Node.js is available on the system.
+ * Updates the `nodeJSAvailable` variable that can be imported from this file.
+ */
+export declare function checkNodeJSAvailable(): Promise<void>;
+/**
+ * Checks wether or not Visual Studio Code is available on the system.
+ * Updates the `visualStudioCodeAvailable` variable that can be imported from this file.
+ */
+export declare function checkVisualStudioCodeAvailable(): Promise<void>;
+/**
+ * Checks wether or not the used package manager (yarn, npm, etc.) is available on the system.
+ * Updates the `packageManagerAvailable` variable that can be imported from this file.
+ * @param packageManager The package manager to check for availability.
+ */
+export declare function checkPackageManagerAvailable(packageManager: EditorProjectPackageManager): Promise<void>;
+/**
+ * Returns wether or not the given package manager is available on the system.
+ * @param packageManager The package manager to check for availability.
+ */
+export declare function isPackageManagerAvailable(packageManager: EditorProjectPackageManager): Promise<boolean>;

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

@@ -0,0 +1,27 @@
+export type ProjectType = {
+    /**
+     * Defines the base64 encoded preview of the project.
+     */
+    preview?: string;
+    /**
+     * Defines the absolute path on the hard drive of the project.
+     */
+    absolutePath: string;
+    /**
+     * Defines the date when the project was created or imported in the dashboard.
+     */
+    createdAt: Date;
+    /**
+     * Defines the date when the project was updated (aka. saved).
+     */
+    updatedAt: Date;
+};
+export declare const temporaryDirectoryName = ".bjseditor";
+export declare const projectsKey: string;
+/**
+ * Ensures that the temporary directory exists for the given project.
+ * This temporary directory is used to store compiled scripts, compressed textures etc.
+ * It is not intended to be pushed to the git repository or packed with the game at the end.
+ * @param projectAbsolutePath defines the aboslute path to the project being edited in the editor.
+ */
+export declare function ensureTemporaryDirectoryExists(projectAbsolutePath: string): Promise<string>;

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

@@ -0,0 +1,15 @@
+/**
+ * Sets the given value (`newValue`) to the property located in the given object.
+ * @param object defines the root object where to parse the property and set its value.
+ * @param property defines the path of the property to set its value.
+ * @param newValue defines the new value to set to the property.
+ */
+export declare function setInspectorEffectivePropertyValue(object: any, property: string, newValue: any): void;
+/**
+ * Returns the current value of the given property of the given object.
+ * @param object defines the root object where to parse the property and return its value.
+ * @param property defines the path of the property to get its value.
+ * @example getInspectorPropertyValue(scene, "ambientColor");
+ * @example getInspectorPropertyValue(scene, "ambientColor.r");
+ */
+export declare function getInspectorPropertyValue(object: any, property: string): any;

package/declaration/src/tools/recast/init.d.ts

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

package/declaration/src/tools/scene/materials.d.ts

@@ -0,0 +1,7 @@
+import { Scene } from "babylonjs";
+/**
+ * Force compile all materials of the given scene.
+ * This is useful to ensure that all materials are compiled and ready to use to avoid lag in the editor.
+ * @param scene The scene to force compile all materials
+ */
+export declare function forceCompileAllSceneMaterials(scene: Scene): Promise<void[]>;

package/declaration/src/tools/scene/play/compile.d.ts

@@ -0,0 +1,4 @@
+export interface ICompilePlayScriptOptions {
+    onTransformSource?: (path: string) => void;
+}
+export declare function compilePlayScript(temporaryDirectory: string, options?: ICompilePlayScriptOptions): Promise<void>;

package/declaration/src/tools/scene/play/override.d.ts

@@ -0,0 +1,7 @@
+import { Editor } from "../../../editor/main";
+/**
+ * To play scene inline in the editor, we need to override some methods.
+ * This function restores all the orignal methods for all object that have been overridden.
+ */
+export declare function restorePlayOverrides(editor: Editor): void;
+export declare function applyOverrides(editor: Editor): void;

package/declaration/src/tools/scene/rename.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Called on a scene has been renamed. This function will update all the references to the old scene
+ * name to the new scene name. Especially the references in the meshes and lods geometry files.
+ * @param oldAbsolutePath defines the old absolute path of the scene folder.
+ * @param newAbsolutePath defines the new absolute path of the scene folder.
+ */
+export declare function renameScene(oldAbsolutePath: string, newAbsolutePath: string): Promise<void>;

package/declaration/src/tools/scene/scene-link.d.ts

@@ -0,0 +1,17 @@
+import { Node, AnimationGroup } from "babylonjs";
+import { Editor } from "../../editor/main";
+import { SceneLinkNode } from "../../editor/nodes/scene-link";
+export declare function createSceneLink(editor: Editor, absolutePath: string): Promise<SceneLinkNode | undefined>;
+/**
+ * Returns wether or not the given node is a descendant of a SceneLinkNode instance.
+ */
+export declare function isFromSceneLink(node: Node): boolean;
+/**
+ * Returns whether or not the given animation group comes from a SceneLinkNode instance.
+ */
+export declare function isAnimationGroupFromSceneLink(animationGroup: AnimationGroup): boolean;
+/**
+ * Returns the firt root SceneLinkNode found for the given node.
+ * In case the node is not from a scene link, "null" is returned.
+ */
+export declare function getRootSceneLink(node: Node): SceneLinkNode | null;

package/declaration/src/tools/scene/screenshot.d.ts

@@ -0,0 +1,11 @@
+import { Scene } from "babylonjs";
+/**
+ * Takes a screenshot of the scene and returns its base64 value.
+ * @param scene defines the reference to the scene to take a screenshot.
+ */
+export declare function getBase64SceneScreenshot(scene: Scene): Promise<string | undefined>;
+/**
+ * Takes a screenshot of the scene and returns its buffer value.
+ * @param scene defines the reference to the scene to take a screenshot.
+ */
+export declare function getBufferSceneScreenshot(scene: Scene): Promise<Buffer<ArrayBuffer> | null>;

package/declaration/src/tools/sound/augmentations.d.ts

@@ -0,0 +1,7 @@
+export { Sound } from "babylonjs";
+declare module "babylonjs" {
+    interface Sound {
+        id: string;
+        uniqueId: number;
+    }
+}