babylonjs-editor 4.5.0 → 5.2.4

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;

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

@@ -0,0 +1,95 @@
+import { Animatable, EasingFunction, Nullable, Scene } from "babylonjs";
+export interface ITweenEasingConfiguration {
+    mode: number;
+    type: EasingFunction;
+}
+export interface ITweenPropertyConfiguration {
+    from: any;
+    to: any;
+    duration?: number;
+    delay?: number;
+    easing?: ITweenEasingConfiguration;
+    value: any;
+}
+export interface ITweenConfiguration {
+    scene?: Scene;
+    delay?: number;
+    easing?: ITweenEasingConfiguration;
+    loop?: boolean;
+    properties?: {
+        [propertyPath: string]: ITweenPropertyConfiguration | any;
+    };
+    onStart?: () => void;
+    onUpdate?: () => void;
+    onComplete?: () => void;
+    [propertyPath: string]: ITweenPropertyConfiguration | any;
+    noOptimize?: boolean;
+    killAllTweensOfTarget?: boolean;
+}
+export declare class Tween {
+    animatables: Animatable[];
+    /**
+     * Defines the reference to the promise resolved on the tween ended.
+     */
+    promise: Promise<void[]>;
+    /**
+     * Constructor.
+     * @param animatable defines the reference to the animatable that is being played.
+     */
+    constructor(animatables: Animatable[]);
+    /**
+     * Pauses the tween animation.
+     */
+    pause(): void;
+    /**
+     * Restarts the animation.
+     */
+    reset(): void;
+    /**
+     * Stops the tween animation. Resolves the promise.
+     */
+    stop(): void;
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then<T1 = void, T2 = never>(onfulfilled?: ((value: any) => T1 | PromiseLike<T1>) | undefined | null, onrejected?: ((reason: any) => T2 | PromiseLike<T2>) | undefined | null): PromiseLike<T1 | T2>;
+    /**
+     * Defines the reference to the scene where to play the tweens.
+     */
+    static Scene: Nullable<Scene>;
+    /**
+     * Defines the default easing function used when playing tweens.
+     */
+    static DefaultEasing: Nullable<ITweenEasingConfiguration>;
+    /**
+     * Kills (stops) all the tweens that animate to given target.
+     * @param target defines the reference to the target to kill all its attached tweens.
+     * @returns true if at least one tween has been killed.
+     */
+    static killTweensOf<T>(target: T | T[]): boolean;
+    static killAllTweens(): void;
+    /**
+     * Creates a new tween reference to anmate CSS properties of the given HTML element for the given duration.
+     * @param target defines the target HTML object to animate its properties.
+     * @param duration defines the duration of the animation(s) expressed in seconds.
+     * @param properties defines the dictionary of all animated properties.
+     * @returns a reference to a tween.
+     */
+    static createForCSS(target: HTMLElement, duration: number, options: ITweenConfiguration): Tween;
+    private static _configureOptions;
+    /**
+     * Creates a new tween reference to animate properties of the given target for the given duration.
+     * @param target defines the target object to animate its properties.
+     * @param duration defines the duration of the animation(s) expressed in seconds.
+     * @param options defines the options the tween (easing, delay, etc.).
+     * @returns a reference to a tween.
+     */
+    static create<T>(target: Nullable<T> | Nullable<T>[], duration: number, options: ITweenConfiguration): Tween;
+    /**
+     * Given a path to a property, return the effective property by deconstructing the path.
+     */
+    private static _getEffectiveTarget;
+}

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

@@ -0,0 +1,10 @@
+interface Keyboard {
+    getLayoutMap(): Promise<KeyboardLayoutMap>;
+}
+interface KeyboardLayoutMap {
+    get(code: string): string | undefined;
+    entries(): IterableIterator<[string, string]>;
+}
+declare interface Navigator {
+    keyboard?: Keyboard;
+}

package/declaration/src/tools/camera/focus.d.ts

@@ -0,0 +1,7 @@
+import { Camera, Vector3 } from "babylonjs";
+export interface ICameraFocusPositionOptions {
+    minimum: Vector3;
+    maximum: Vector3;
+    distance?: number;
+}
+export declare function getCameraFocusPositionFor(target: Vector3, camera: Camera, options: ICameraFocusPositionOptions): Vector3;

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

@@ -0,0 +1,14 @@
+import { FileFilter } from "electron";
+export type OpenFileDialogOptions = {
+    title?: string;
+    filters?: FileFilter[];
+};
+export declare function openSingleFileDialog(options?: OpenFileDialogOptions): string;
+export declare function openMultipleFilesDialog(options?: OpenFileDialogOptions): string[];
+export declare function openSingleFolderDialog(title?: string): string;
+export type SaveFileDialogOptions = {
+    title?: string;
+    defaultPath?: string;
+    filters?: FileFilter[];
+};
+export declare function saveSingleFileDialog(options?: SaveFileDialogOptions): string;

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

@@ -0,0 +1,17 @@
+/**
+ * Returns wether or not the given DOM element is focusable.
+ * Aka `input`, `select`, `button`, `textarea` etc.
+ * @param element defines the reference to the DOM element to check.
+ * @returns wether or not the given DOM element is focusable.
+ */
+export declare function isDomElementFocusable(element: Element | null | undefined): boolean;
+/**
+ * Returns wether or not the given DOM element is a descendant of the given parent.
+ * @param element defines the reference to the DOM element to check.
+ * @param parent defines the reference to the parent DOM element to check against.
+ */
+export declare function isDomElementDescendantOf(element: HTMLElement, parent: HTMLElement): boolean;
+/**
+ * Returns wether or not the currently focused DOM element is any text input.
+ */
+export declare function isDomTextInputFocused(): boolean;

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

@@ -0,0 +1,30 @@
+import { glob } from "glob";
+/**
+ * Creates a directory if it doesn't exist.
+ * @param absolutePath the absolute path of the directory to create.
+ */
+export declare function createDirectoryIfNotExist(absolutePath: string): Promise<void>;
+/**
+ * Normalizes the paths of the files returned by glob.
+ */
+export declare function normalizedGlob(...args: Parameters<typeof glob>): ReturnType<typeof glob>;
+/**
+ * Creates a new FS watcher and returns its reference. Takes care of waiting enought time in order
+ * to notify the "change" event only once.
+ * @param absolutePath defines the absolute path to the file to watch.
+ * @param onChange defines the callback called when the file changed.
+ */
+export declare function watchFile(absolutePath: string, onChange: () => void): import("chokidar").FSWatcher;
+/**
+ * Finds an available filename for the given filename and extension in the specified directory.
+ * @param absoluteDirname defines the absolute path of the directory to search in
+ * @param originalName defines the original name of the file
+ * @param extension defines the file extension (without dot)
+ */
+export declare function findAvailableFilename(absoluteDirname: string, originalName: string, extension: string): Promise<string>;
+/**
+ * Tries to read a directory and returns its content if the directory exists.
+ * If not, returns an empty array.
+ * @param path defines the absolute path to read directory.
+ */
+export declare function tryReadDir(path: string): Promise<string[]>;

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

@@ -0,0 +1,21 @@
+import { MultiMaterial, NodeMaterial, PBRMaterial, StandardMaterial } from "babylonjs";
+/**
+ * Returns wether or not the given object is a StandardMaterial.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isStandardMaterial(object: any): object is StandardMaterial;
+/**
+ * Returns wether or not the given object is a PBRMaterial.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isPBRMaterial(object: any): object is PBRMaterial;
+/**
+ * Returns wether or not the given object is a NodeMaterial.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isNodeMaterial(object: any): object is NodeMaterial;
+/**
+ * Returns wether or not the given object is a MultiMaterial.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isMultiMaterial(object: any): object is MultiMaterial;

package/declaration/src/tools/guards/math.d.ts

@@ -0,0 +1,26 @@
+import { Quaternion, Vector2, Vector3, Color3, Color4 } from "babylonjs";
+/**
+ * Returns wether or not the given object is a Vector2.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isVector2(object: any): object is Vector2;
+/**
+ * Returns wether or not the given object is a Vector3.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isVector3(object: any): object is Vector3;
+/**
+ * Returns wether or not the given object is a Quaternion.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isQuaternion(object: any): object is Quaternion;
+/**
+ * Returns wether or not the given object is a Color3.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isColor3(object: any): object is Color3;
+/**
+ * Returns wether or not the given object is a Color4.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isColor4(object: any): object is Color4;

package/declaration/src/tools/guards/nodes.d.ts

@@ -0,0 +1,103 @@
+import { Bone, Camera, GroundMesh, Light, Mesh, Node, PointLight, TransformNode, DirectionalLight, InstancedMesh, FreeCamera, ArcRotateCamera, SpotLight, HemisphericLight, Skeleton } from "babylonjs";
+import { EditorCamera } from "../../editor/nodes/camera";
+import { CollisionMesh } from "../../editor/nodes/collision";
+/**
+ * Returns wether or not the given object is an AbstractMesh.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isAbstractMesh(object: any): object is Mesh;
+/**
+ * Returns wether or not the given object is a Mesh.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isMesh(object: any): object is Mesh;
+/**
+ * Returns wether or not the given object is a InstancedMesh.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isInstancedMesh(object: any): object is InstancedMesh;
+/**
+ * Returns wether or not the given object is a Bone.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isBone(object: any): object is Bone;
+/**
+ * Returns wether or not the given object is a GroundMesh.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isGroundMesh(object: any): object is GroundMesh;
+/**
+ * Returns wether or not the given object is a CollisionMesh.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isCollisionMesh(object: any): object is CollisionMesh;
+/**
+ * Returns wether or not the given object is an InstancedMesh of CollisionMesh.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isCollisionInstancedMesh(object: any): object is InstancedMesh;
+/**
+ * Returns wether or not the given object is a TransformNode.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isTransformNode(object: any): object is TransformNode;
+/**
+ * Returns wether or not the given object is a Skeleton.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isSkeleton(object: any): object is Skeleton;
+/**
+ * Returns wether or not the given object is a Any TransformNode.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isAnyTransformNode(object: any): object is TransformNode;
+/**
+ * Returns wether or not the given object is a Camera.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isCamera(object: any): object is Camera;
+/**
+ * Returns wether or not the given object is a EditorCamera.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isEditorCamera(object: any): object is EditorCamera;
+/**
+ * Returns wether or not the given object is a FreeCamera.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isFreeCamera(object: any): object is FreeCamera;
+/**
+ * Returns wether or not the given object is a ArcRotateCamera.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isArcRotateCamera(object: any): object is ArcRotateCamera;
+/**
+ * Returns wether or not the given object is a PointLight.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isPointLight(object: any): object is PointLight;
+/**
+ * Returns wether or not the given object is a DirectionalLight.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isDirectionalLight(object: any): object is DirectionalLight;
+/**
+ * Returns wether or not the given object is a SpotLight.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isSpotLight(object: any): object is SpotLight;
+/**
+ * Returns wether or not the given object is a HemisphericLight.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isHemisphericLight(object: any): object is HemisphericLight;
+/**
+ * Returns wether or not the given object is a Light.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isLight(object: any): object is Light;
+/**
+ * Returns wether or not the given object is a Node.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isNode(object: any): object is Node;

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

@@ -0,0 +1,16 @@
+import { ParticleSystem, GPUParticleSystem, IParticleSystem } from "babylonjs";
+/**
+ * Returns wether or not the given object is a ParticleSystem.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isParticleSystem(object: any): object is ParticleSystem;
+/**
+ * Returns wether or not the given object is a GPUParticleSystem.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isGPUParticleSystem(object: any): object is GPUParticleSystem;
+/**
+ * Returns wether or not the given object is a IParticleSystem.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isAnyParticleSystem(object: any): object is IParticleSystem;

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

@@ -0,0 +1,12 @@
+import { Scene } from "babylonjs";
+import { SceneLinkNode } from "../../editor/nodes/scene-link";
+/**
+ * Returns wether or not the given object is a Scene.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isScene(object: any): object is Scene;
+/**
+ * Returns wether or not the given object is a SceneLinkNode.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isSceneLinkNode(object: any): object is SceneLinkNode;

package/declaration/src/tools/guards/shadows.d.ts

@@ -0,0 +1,11 @@
+import { CascadedShadowGenerator, ShadowGenerator } from "babylonjs";
+/**
+ * Returns wether or not the given object is a ShadowGenerator.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isShadowGenerator(object: any): object is ShadowGenerator;
+/**
+ * Returns wether or not the given object is a CascadedShadowGenerator.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isCascadedShadowGenerator(object: any): object is CascadedShadowGenerator;

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

@@ -0,0 +1,6 @@
+import { Sound } from "babylonjs";
+/**
+ * Returns wether or not the given object is a Sound.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isSound(object: any): object is Sound;

package/declaration/src/tools/guards/sprites.d.ts

@@ -0,0 +1,18 @@
+import { SpriteMapNode } from "../../editor/nodes/sprite-map";
+import { SpriteManagerNode } from "../../editor/nodes/sprite-manager";
+import { Sprite } from "babylonjs";
+/**
+ * Returns wether or not the given object is a Sprite.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isSprite(object: any): object is Sprite;
+/**
+ * Returns wether or not the given object is a SpriteMapNode.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isSpriteMapNode(object: any): object is SpriteMapNode;
+/**
+ * Returns wether or not the given object is a SpriteManagerNode.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isSpriteManagerNode(object: any): object is SpriteManagerNode;

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

@@ -0,0 +1,22 @@
+import { AdvancedDynamicTexture } from "babylonjs-gui";
+import { CubeTexture, Texture, ColorGradingTexture } from "babylonjs";
+/**
+ * Returns wether or not the given object is a Texture.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isTexture(object: any): object is Texture;
+/**
+ * Returns wether or not the given object is a CubeTexture.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isCubeTexture(object: any): object is CubeTexture;
+/**
+ * Returns wether or not the given object is a AdvancedDynamicTexture.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isAdvancedDynamicTexture(object: any): object is AdvancedDynamicTexture;
+/**
+ * Returns wether or not the given object is a ColorGradingTexture.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isColorGradingTexture(object: any): object is ColorGradingTexture;

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

@@ -0,0 +1,14 @@
+/**
+ * Sends an IPC message to the main process and waits for a response.
+ * @param id The id of the IPC message.
+ * @param args The arguments to pass to the IPC message.
+ * @returns A promise that resolves with the response from the main process.
+ */
+export declare function ipcSendAsync<T>(id: string, ...args: any[]): Promise<T>;
+/**
+ * Sends an IPC message to the main process and waits for a response.
+ * @param id The id of the IPC message.
+ * @param args The arguments to pass to the IPC message.
+ * @returns A promise that resolves with the response from the main process.
+ */
+export declare function ipcSendAsyncWithMessageId<T>(id: string, ...args: any[]): Promise<T>;

package/declaration/src/tools/light/ibl.d.ts

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

package/declaration/src/tools/light/shadows.d.ts

@@ -0,0 +1,19 @@
+import { Light, Scene } from "babylonjs";
+/**
+ * Updates the shadow map render list predicate of the given point light.
+ * Will basically filter out meshes that are too far from the light according to
+ * the current light's `range` value.
+ * @param light defines the reference to the point light to configure.
+ */
+export declare function updatePointLightShadowMapRenderListPredicate(light: Light): void;
+/**
+ * In case the light has a refresh rate of 0, let's update them to reset refresh rate to
+ * 0 in order to re-trigger a render of the shadow map. This is typically used when a light is moved in the editor.
+ * @param light defines the reference to the light to configure.
+ */
+export declare function updateLightShadowMapRefreshRate(light: Light): void;
+/**
+ * Updates all the lights properties (shadow maps, list predicates etc.).
+ * @param scene defines the reference to the scene that contains all lights to update.
+ */
+export declare function updateAllLights(scene: Scene): void;

package/declaration/src/tools/local-storage.d.ts

@@ -0,0 +1,29 @@
+import { ProjectType } from "./project";
+/**
+ * Returns the list of projects that were stored in the local storage in order to display them in the dashboard.
+ * Those projects are sorted by the last updated date.
+ */
+export declare function tryGetProjectsFromLocalStorage(): ProjectType[];
+/**
+ * Adds the project located at the given absolute path to the local storage in order to display them in the dashboard.
+ * @param absolutePath defines the absolute path to the project file to add to the local storage.
+ */
+export declare function tryAddProjectToLocalStorage(absolutePath: string): void;
+/**
+ * Returns wether or not experimental features are enabled in the editor.
+ */
+export declare function tryGetExperimentalFeaturesEnabledFromLocalStorage(): boolean;
+/**
+ * Sets whether or not experimental features are enabled in the local storage.
+ * @param enabled defines wether or not experimental features are enabled.
+ */
+export declare function trySetExperimentalFeaturesEnabledInLocalStorage(enabled: boolean): void;
+/**
+ * Returns wether or not the dashboard should be closed when a project is opened.
+ */
+export declare function tryGetCloseDashboardOnProjectOpenFromLocalStorage(): boolean;
+/**
+ * Sets whether or not the dashboard should be closed when a project is opened.
+ * @param enabled defines whether or not the dashboard should be closed when a project is opened.
+ */
+export declare function trySetCloseDashboardOnProjectOpenInLocalStorage(enabled: boolean): void;

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<void>;

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/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;