babylonjs-editor-tools 0.0.10 → 0.0.11

package/declaration/src/cinematic/events/apply-impulse.d.ts

@@ -0,0 +1,8 @@
+import { Scene } from "@babylonjs/core/scene";
+export type SetEnabledEventType = {
+    mesh: string;
+    radius: number;
+    force: number[];
+    contactPoint: number[];
+};
+export declare function handleApplyImpulseEvent(scene: Scene, config: SetEnabledEventType): void;

package/declaration/src/cinematic/events/set-enabled.d.ts

@@ -0,0 +1,6 @@
+import { Scene } from "@babylonjs/core/scene";
+export type SetEnabledEventType = {
+    value: boolean;
+    node: string;
+};
+export declare function handleSetEnabledEvent(scene: Scene, config: SetEnabledEventType): void;

package/declaration/src/cinematic/generate.d.ts

@@ -0,0 +1,9 @@
+import { Scene } from "@babylonjs/core/scene";
+import { AnimationGroup } from "@babylonjs/core/Animations/animationGroup";
+import { ICinematic } from "./typings";
+/**
+ * Parses the given cinematic object and generates a new playable animation group.
+ * @param cinematic defines the cinematic object to parse that was previously loaded.
+ * @param scene defines the reference to the scene where to retrieve the animated objects.
+ */
+export declare function generateCinematicAnimationGroup(cinematic: ICinematic, scene: Scene): AnimationGroup;

package/declaration/src/cinematic/parse.d.ts

@@ -0,0 +1,15 @@
+import { Scene } from "@babylonjs/core/scene";
+import { ICinematic } from "./typings";
+/**
+ * Parses the given JSON data and returns a new cinematic object.
+ * @param data defines the JSON data of the cinematic to parse.
+ * @param scene defines the reference to the scene used to retrieve cinematic's data.
+ */
+export declare function parseCinematic(data: ICinematic, scene: Scene): ICinematic;
+/**
+ * Parses the given value and returns the reference to the right value to be animated.
+ * @param value defines the raw value to parse (ie. number or array for vectors).
+ * @param type defines the type of the property animated.
+ * @example [0, 0, 0] with type Animation.ANIMATIONTYPE_VECTOR3 will return a new Vector3(0, 0, 0) object.
+ */
+export declare function parseCinematicKeyValue(value: any, type: number): any;

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

@@ -0,0 +1,15 @@
+import { IAnimationKey } from "@babylonjs/core/Animations/animationKey";
+export declare function cloneKey(dataType: number, key: IAnimationKey): IAnimationKey;
+/**
+ * Returns the animation type according to the given animated property type.
+ * @param effectiveProperty defines the reference to the animated property to get its animation type.
+ */
+export declare function getAnimationTypeForObject(effectiveProperty: any): number | null;
+/**
+ * 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 getPropertyValue(scene, "ambientColor");
+ * @example getPropertyValue(scene, "ambientColor.r");
+ */
+export declare function getPropertyValue(object: any, property: string): any;

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

@@ -0,0 +1,44 @@
+import { IAnimationKey } from "@babylonjs/core/Animations/animationKey";
+export interface ICinematic {
+    name: string;
+    framesPerSecond: number;
+    tracks: ICinematicTrack[];
+    outputFramesPerSecond: number;
+}
+export interface ICinematicTrack {
+    animationGroup?: any;
+    animationGroups?: ICinematicAnimationGroup[];
+    node?: any;
+    defaultRenderingPipeline?: boolean;
+    sound?: any;
+    sounds?: ICinematicSound[];
+    propertyPath?: string;
+    keyFrameAnimations?: (ICinematicKey | ICinematicKeyCut)[];
+    keyFrameEvents?: ICinematicKeyEvent[];
+}
+export interface ICinematicAnimationGroup {
+    type: "group";
+    frame: number;
+    speed: number;
+    startFrame: number;
+    endFrame: number;
+}
+export interface ICinematicKey extends IAnimationKey {
+    type: "key" | "cut";
+}
+export interface ICinematicKeyCut {
+    type: "cut";
+    key1: IAnimationKey;
+    key2: IAnimationKey;
+}
+export interface ICinematicSound {
+    type: "sound";
+    frame: number;
+    startFrame: number;
+    endFrame: number;
+}
+export interface ICinematicKeyEvent {
+    type: "event";
+    frame: number;
+    data?: any;
+}

package/declaration/src/decorators/apply.d.ts

@@ -0,0 +1,37 @@
+import { Scene } from "@babylonjs/core/scene";
+import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
+import { VisibleInInspectorDecoratorConfiguration } from "./inspector";
+export interface ISceneDecoratorData {
+    _NodesFromScene: {
+        nodeName: string;
+        propertyKey: string | Symbol;
+    }[];
+    _NodesFromDescendants: {
+        nodeName: string;
+        propertyKey: string | Symbol;
+        directDescendantsOnly: boolean;
+    }[];
+    _AnimationGroups: {
+        animationGroupName: string;
+        propertyKey: string | Symbol;
+    }[];
+    _SoundsFromScene: {
+        soundName: string;
+        propertyKey: string | Symbol;
+    }[];
+    _GuiFromAsset: {
+        pathInAssets: string;
+        onGuiCreated?: (instance: unknown, gui: AdvancedDynamicTexture) => unknown;
+        propertyKey: string | Symbol;
+    }[];
+    _ParticleSystemsFromScene: {
+        particleSystemName: string;
+        propertyKey: string | Symbol;
+    }[];
+    _VisibleInInspector: {
+        label?: string;
+        propertyKey: string | Symbol;
+        configuration: VisibleInInspectorDecoratorConfiguration;
+    }[];
+}
+export declare function applyDecorators(scene: Scene, object: any, script: any, instance: any, rootUrl: string): void;

package/declaration/src/decorators/gui.d.ts

@@ -0,0 +1,12 @@
+import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
+/**
+ * Makes the decorated property linked to the GUI created from the given asset file.
+ * Once the script is instantiated, the reference to the gui texture is created from the asset file
+ * and assigned to the property. Gui link cant' be used in constructor and its creation is asynchronous.
+ * @param pathInAssets defines the relative path (as it is in the assets browser in the editor) to the .gui file.
+ * @param onGuiCreated defines the optional callback that is called when the GUI is created.
+ * @example
+ *  @guiFromAsset<MyScriptClass>("ui.gui", (instance, gui) => instance._onGuiLoaded(gui))
+ *  private _ui!: AdvancedDynamicTexture;
+ */
+export declare function guiFromAsset<T>(pathInAssets: string, onGuiCreated?: (instance: T, gui: AdvancedDynamicTexture) => unknown): (target: any, propertyKey: string | Symbol) => void;

package/declaration/src/decorators/inspector.d.ts

@@ -0,0 +1,82 @@
+export type VisibleInInspectorDecoratorType = "number" | "boolean" | "vector2" | "vector3" | "color3" | "color4";
+export type VisibleInInspectorDecoratorConfiguration = {
+    type: VisibleInInspectorDecoratorType;
+};
+/**
+ * Makes the decorated property visible in the editor inspector as a boolean.
+ * The property can be customized per object in the editor and the custom value is applied
+ * once the script is invoked at runtime in the game/application.
+ * This can be used only by scripts using Classes.
+ * @param label defines the optional label displayed in the inspector in the editor.
+ */
+export declare function visibleAsBoolean(label?: string): (target: any, propertyKey: string | Symbol) => void;
+/**
+ * Makes the decorated property visible in the editor inspector as a number.
+ * The property can be customized per object in the editor and the custom value is applied
+ * once the script is invoked at runtime in the game/application.
+ * This can be used only by scripts using Classes.
+ * @param label defines the optional label displayed in the inspector in the editor.
+ * @param configuration defines the optional configuration for the field in the inspector (min, max, etc.).
+ */
+export declare function visibleAsNumber(label?: string, configuration?: Omit<VisibleInInspectorDecoratorNumberConfiguration, "type">): (target: any, propertyKey: string | Symbol) => void;
+export type VisibleInInspectorDecoratorNumberConfiguration = VisibleInInspectorDecoratorConfiguration & {
+    min?: number;
+    max?: number;
+    step?: number;
+};
+/**
+ * Makes the decorated property visible in the editor inspector as a vector2.
+ * The property can be customized per object in the editor and the custom value is applied
+ * once the script is invoked at runtime in the game/application.
+ * This can be used only by scripts using Classes.
+ * @param label defines the optional label displayed in the inspector in the editor.
+ * @param configuration defines the optional configuration for the field in the inspector (min, max, etc.).
+ */
+export declare function visibleAsVector2(label?: string, configuration?: Omit<VisibleInInspectorDecoratorVector2Configuration, "type">): (target: any, propertyKey: string | Symbol) => void;
+export type VisibleInInspectorDecoratorVector2Configuration = VisibleInInspectorDecoratorConfiguration & {
+    min?: number;
+    max?: number;
+    step?: number;
+    asDegrees?: boolean;
+};
+/**
+ * Makes the decorated property visible in the editor inspector as a vector3.
+ * The property can be customized per object in the editor and the custom value is applied
+ * once the script is invoked at runtime in the game/application.
+ * This can be used only by scripts using Classes.
+ * @param label defines the optional label displayed in the inspector in the editor.
+ * @param configuration defines the optional configuration for the field in the inspector (min, max, etc.).
+ */
+export declare function visibleAsVector3(label?: string, configuration?: Omit<VisibleInInspectorDecoratorVector3Configuration, "type">): (target: any, propertyKey: string | Symbol) => void;
+export type VisibleInInspectorDecoratorVector3Configuration = VisibleInInspectorDecoratorConfiguration & {
+    min?: number;
+    max?: number;
+    step?: number;
+    asDegrees?: boolean;
+};
+/**
+ * Makes the decorated property visible in the editor inspector as a color3.
+ * The property can be customized per object in the editor and the custom value is applied
+ * once the script is invoked at runtime in the game/application.
+ * This can be used only by scripts using Classes.
+ * @param label defines the optional label displayed in the inspector in the editor.
+ * @param configuration defines the optional configuration for the field in the inspector (min, max, etc.).
+ */
+export declare function visibleAsColor3(label?: string, configuration?: Omit<VisibleInInspectorDecoratorColor3Configuration, "type">): (target: any, propertyKey: string | Symbol) => void;
+export type VisibleInInspectorDecoratorColor3Configuration = VisibleInInspectorDecoratorConfiguration & {
+    noClamp?: boolean;
+    noColorPicker?: boolean;
+};
+/**
+ * Makes the decorated property visible in the editor inspector as a color4.
+ * The property can be customized per object in the editor and the custom value is applied
+ * once the script is invoked at runtime in the game/application.
+ * This can be used only by scripts using Classes.
+ * @param label defines the optional label displayed in the inspector in the editor.
+ * @param configuration defines the optional configuration for the field in the inspector (min, max, etc.).
+ */
+export declare function visibleAsColor4(label?: string, configuration?: Omit<VisibleInInspectorDecoratorColor4Configuration, "type">): (target: any, propertyKey: string | Symbol) => void;
+export type VisibleInInspectorDecoratorColor4Configuration = VisibleInInspectorDecoratorConfiguration & {
+    noClamp?: boolean;
+    noColorPicker?: boolean;
+};

package/declaration/src/decorators/particle-systems.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Makes the decorated property linked to the particle system that has the given name.
+ * Once the script is instantiated, the reference to the particle system is retrieved
+ * from the scene and assigned to the property. Node link cant' be used in constructor.
+ * This can be used only by scripts using Classes.
+ * @param particleSystemName defines the name of the sound to retrieve in scene.
+ */
+export declare function particleSystemFromScene(particleSystemName: string): (target: any, propertyKey: string | Symbol) => void;

package/declaration/src/decorators/scene.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Makes the decorated property linked to the node that has the given name.
+ * Once the script is instantiated, the reference to the node is retrieved from the scene
+ * and assigned to the property. Node link cant' be used in constructor.
+ * This can be used only by scripts using Classes.
+ * @param nodeName defines the name of the node to retrieve in scene.
+ */
+export declare function nodeFromScene(nodeName: string): (target: any, propertyKey: string | Symbol) => void;
+/**
+ * Makes the decorated property linked to the node that has the given name.
+ * Once the script is instantiated, the reference to the node is retrieved from the descendants
+ * of the current node and assigned to the property. Node link cant' be used in constructor.
+ * This can be used only by scripts using Classes.
+ * @param nodeName defines the name of the node to retrieve in scene.
+ * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered.
+ */
+export declare function nodeFromDescendants(nodeName: string, directDescendantsOnly?: boolean): (target: any, propertyKey: string | Symbol) => void;
+/**
+ * Makes the decorated property linked to an animation group that has the given name.
+ * Once the script is instantiated, the reference to the animation group is retrieved from the scene
+ * and assigned to the property. Animation group link cant' be used in constructor.
+ * This can be used only by scripts using Classes.
+ * @param animationGroupName defines the name of the animation group to retrieve in scene.
+ */
+export declare function animationGroupFromScene(animationGroupName: string): (target: any, propertyKey: string | Symbol) => void;

package/declaration/src/decorators/sound.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Makes the decorated property linked to the sound that has the given name.
+ * Once the script is instantiated, the reference to the sound is retrieved from the scene
+ * and assigned to the property. Node link cant' be used in constructor.
+ * This can be used only by scripts using Classes.
+ * @param soundName defines the name of the sound to retrieve in scene.
+ */
+export declare function soundFromScene(soundName: string): (target: any, propertyKey: string | Symbol) => void;

package/declaration/src/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./loading/loader";
+export * from "./tools/guards";
+export * from "./tools/texture";
+export * from "./tools/light";
+export * from "./tools/scalar";
+export * from "./rendering/ssao";
+export * from "./rendering/ssr";
+export * from "./rendering/motion-blur";
+export * from "./rendering/default-pipeline";
+export * from "./rendering/vls";
+export * from "./decorators/scene";
+export * from "./decorators/gui";
+export * from "./decorators/sound";
+export * from "./decorators/particle-systems";
+export * from "./decorators/inspector";
+export * from "./script";
+export * from "./cinematic/parse";
+export * from "./cinematic/typings";
+export * from "./cinematic/generate";

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

@@ -0,0 +1,35 @@
+import { Scene } from "@babylonjs/core/scene";
+import "./sound";
+import "./texture";
+/**
+ * Defines the possible output type of a script.
+ * `default` is a class that will be instantiated with the object as parameter.
+ * `onStart` is a function that will be called once before the first render passing the reference to the object the script is attached to.
+ * `onUpdate` is a function that will be called every frame passing the reference to the object the script is attached to
+ */
+export type ScriptMap = Record<string, {
+    default?: new (object: any) => {
+        onStart?(): void;
+        onUpdate?(): void;
+    };
+    onStart?: (object: any) => void;
+    onUpdate?: (object: any) => void;
+}>;
+/**
+ * Defines the overall desired quality of the scene.
+ * In other words, defines the quality of textures that will be loaded in terms of dimensions.
+ * The editor computes automatic "hight (untouched)", "medium (half)", and "low (quarter)" quality levels for textures.
+ * Using "medium" or "low" quality levels will reduce the memory usage and improve the performance of the scene
+ * especially on mobiles where memory is limited.
+ */
+export type SceneLoaderQualitySelector = "low" | "medium" | "high";
+export type SceneLoaderOptions = {
+    quality?: SceneLoaderQualitySelector;
+    onProgress?: (value: number) => void;
+};
+declare module "@babylonjs/core/scene" {
+    interface Scene {
+        loadingQuality: SceneLoaderQualitySelector;
+    }
+}
+export declare function loadScene(rootUrl: any, sceneFilename: string, scene: Scene, scriptsMap: ScriptMap, options?: SceneLoaderOptions): Promise<void>;

package/declaration/src/loading/physics.d.ts

@@ -0,0 +1,6 @@
+import { AbstractMesh } from "@babylonjs/core/Meshes/abstractMesh";
+/**
+ * Parses and loads the physics aggregate data for the given mesh.
+ * @param mesh defines the reference to the mesh object.
+ */
+export declare function configurePhysicsAggregate(transformNode: AbstractMesh): void;

package/declaration/src/loading/rendering.d.ts

@@ -0,0 +1,2 @@
+import { Scene } from "@babylonjs/core/scene";
+export declare function applyRenderingConfigurations(scene: Scene, rendering: any): void;

package/declaration/src/loading/script.d.ts

@@ -0,0 +1,3 @@
+import { Scene } from "@babylonjs/core/scene";
+import { ScriptMap } from "./loader";
+export declare function applyScriptForObject(scene: Scene, object: any, scriptsMap: ScriptMap, rootUrl: string): void;

package/declaration/src/loading/sound.d.ts

@@ -0,0 +1 @@
+export {};

package/declaration/src/loading/texture.d.ts

@@ -0,0 +1 @@
+export {};

package/declaration/src/rendering/default-pipeline.d.ts

@@ -0,0 +1,15 @@
+import { Scene } from "@babylonjs/core/scene";
+import { Camera } from "@babylonjs/core/Cameras/camera";
+import { DefaultRenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/defaultRenderingPipeline";
+/**
+ * Defines the configuration of the default rendering pipeline per camera.
+ */
+export declare const defaultPipelineCameraConfigurations: Map<Camera, any>;
+/**
+ * Returns the reference to the default rendering pipeline if exists.
+ */
+export declare function getDefaultRenderingPipeline(): DefaultRenderingPipeline | null;
+export declare function disposeDefaultRenderingPipeline(): void;
+export declare function createDefaultRenderingPipeline(scene: Scene, camera: Camera): DefaultRenderingPipeline;
+export declare function serializeDefaultRenderingPipeline(): any;
+export declare function parseDefaultRenderingPipeline(scene: Scene, camera: Camera, data: any): DefaultRenderingPipeline;

package/declaration/src/rendering/motion-blur.d.ts

@@ -0,0 +1,12 @@
+import { Scene } from "@babylonjs/core/scene";
+import { Camera } from "@babylonjs/core/Cameras/camera";
+import { MotionBlurPostProcess } from "@babylonjs/core/PostProcesses/motionBlurPostProcess";
+/**
+ * Defines the configuration of the motion blur post-process per camera.
+ */
+export declare const motionBlurPostProcessCameraConfigurations: Map<Camera, any>;
+export declare function getMotionBlurPostProcess(): MotionBlurPostProcess | null;
+export declare function disposeMotionBlurPostProcess(): void;
+export declare function createMotionBlurPostProcess(scene: Scene, camera: Camera): MotionBlurPostProcess;
+export declare function serializeMotionBlurPostProcess(): any;
+export declare function parseMotionBlurPostProcess(scene: Scene, camera: Camera, data: any): MotionBlurPostProcess;

package/declaration/src/rendering/ssao.d.ts

@@ -0,0 +1,12 @@
+import { Scene } from "@babylonjs/core/scene";
+import { Camera } from "@babylonjs/core/Cameras/camera";
+import { SSAO2RenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/ssao2RenderingPipeline";
+/**
+ * Defines the configuration of the SSAO rendering pipeline per camera.
+ */
+export declare const ssaoRenderingPipelineCameraConfigurations: Map<Camera, any>;
+export declare function getSSAO2RenderingPipeline(): SSAO2RenderingPipeline | null;
+export declare function disposeSSAO2RenderingPipeline(): void;
+export declare function createSSAO2RenderingPipeline(scene: Scene, camera: Camera): SSAO2RenderingPipeline;
+export declare function serializeSSAO2RenderingPipeline(): any;
+export declare function parseSSAO2RenderingPipeline(scene: Scene, camera: Camera, data: any): SSAO2RenderingPipeline;

package/declaration/src/rendering/ssr.d.ts

@@ -0,0 +1,12 @@
+import { Scene } from "@babylonjs/core/scene";
+import { Camera } from "@babylonjs/core/Cameras/camera";
+import { SSRRenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/ssrRenderingPipeline";
+/**
+ * Defines the configuration of the ssr rendering pipeline per camera.
+ */
+export declare const ssrRenderingPipelineCameraConfigurations: Map<Camera, any>;
+export declare function getSSRRenderingPipeline(): SSRRenderingPipeline | null;
+export declare function disposeSSRRenderingPipeline(): void;
+export declare function createSSRRenderingPipeline(scene: Scene, camera: Camera): SSRRenderingPipeline;
+export declare function serializeSSRRenderingPipeline(): any;
+export declare function parseSSRRenderingPipeline(scene: Scene, camera: Camera, data: any): SSRRenderingPipeline;

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

@@ -0,0 +1,14 @@
+import { Camera } from "@babylonjs/core/Cameras/camera";
+/**
+ * Saves the rendering configurations for the given camera. This is useful to restore the rendering configurations
+ * when the camera is re-activated (typically using the preview panel toolbar).
+ * @param camera defines the reference to the camera to save its rendering configurations.
+ */
+export declare function saveRenderingConfigurationForCamera(camera: Camera): void;
+/**
+ * Applies the post-processes configurations for the given camera. Rendering configurations (motion blur, ssao, etc.) are
+ * saved per-camera and can be applied on demand using this function.
+ * Previous post-processes configurations are disposed before applying the new ones.
+ * @param camera defines the reference to the camera to apply its rendering configurations.
+ */
+export declare function applyRenderingConfigurationForCamera(camera: Camera): void;

package/declaration/src/rendering/vls.d.ts

@@ -0,0 +1,13 @@
+import { Scene } from "@babylonjs/core/scene";
+import { Mesh } from "@babylonjs/core/Meshes/mesh";
+import { Camera } from "@babylonjs/core/Cameras/camera";
+import { VolumetricLightScatteringPostProcess } from "@babylonjs/core/PostProcesses/volumetricLightScatteringPostProcess";
+/**
+ * Defines the configuration of the motion blur post-process per camera.
+ */
+export declare const vlsPostProcessCameraConfigurations: Map<Camera, any>;
+export declare function getVLSPostProcess(): VolumetricLightScatteringPostProcess | null;
+export declare function disposeVLSPostProcess(scene: Scene): void;
+export declare function createVLSPostProcess(scene: Scene, mesh?: Mesh | null): VolumetricLightScatteringPostProcess;
+export declare function serializeVLSPostProcess(): any;
+export declare function parseVLSPostProcess(scene: Scene, data: any): VolumetricLightScatteringPostProcess;

package/declaration/src/script.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Defines the interface that can be implemented by scripts attached to nodes in the editor.
+ */
+export interface IScript {
+    /**
+     * Method called when the script starts. This method is called only once.
+     */
+    onStart?(): void;
+    /**
+     * Method called on each frame.
+     */
+    onUpdate?(): void;
+}

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

@@ -0,0 +1,83 @@
+import { Bone } from "@babylonjs/core/Bones/bone";
+import { Mesh } from "@babylonjs/core/Meshes/mesh";
+import { GroundMesh } from "@babylonjs/core/Meshes/groundMesh";
+import { InstancedMesh } from "@babylonjs/core/Meshes/instancedMesh";
+import { TransformNode } from "@babylonjs/core/Meshes/transformNode";
+import { Texture } from "@babylonjs/core/Materials/Textures/texture";
+import { Camera } from "@babylonjs/core/Cameras/camera";
+import { FreeCamera } from "@babylonjs/core/Cameras/freeCamera";
+import { ArcRotateCamera } from "@babylonjs/core/Cameras/arcRotateCamera";
+import { SpotLight } from "@babylonjs/core/Lights/spotLight";
+import { PointLight } from "@babylonjs/core/Lights/pointLight";
+import { HemisphericLight } from "@babylonjs/core/Lights/hemisphericLight";
+import { DirectionalLight } from "@babylonjs/core/Lights/directionalLight";
+/**
+ * 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 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 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 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 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;

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

@@ -0,0 +1,3 @@
+import { Scene } from "@babylonjs/core/scene";
+export declare function configureShadowMapRenderListPredicate(scene: Scene): void;
+export declare function configureShadowMapRefreshRate(scene: Scene): Promise<void>;

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

@@ -0,0 +1,6 @@
+import { PhysicsAggregate } from "@babylonjs/core/Physics/v2/physicsAggregate";
+declare module "@babylonjs/core/Meshes/abstractMesh" {
+    interface AbstractMesh {
+        physicsAggregate?: PhysicsAggregate | null;
+    }
+}

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

@@ -0,0 +1 @@
+export declare function getPowerOfTwoUntil(limit: number): number;

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

@@ -0,0 +1,13 @@
+import { Scene } from "@babylonjs/core/scene";
+declare module "@babylonjs/core/Audio/sound" {
+    interface Sound {
+        id: string;
+        uniqueId: number;
+    }
+}
+/**
+ * Searches for a sound by its id in the scene by traversing all soundtracks.
+ * @param id defines the id of the sound to retrieve.
+ * @param scene defines the reference to the scene where to find the instantiated sound.
+ */
+export declare function getSoundById(id: string, scene: Scene): import("@babylonjs/core").Sound | null;

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

@@ -0,0 +1,8 @@
+import { Engine } from "@babylonjs/core/Engines/engine";
+/**
+ * Set the compressed texture format to use, based on the formats you have, and the formats
+ * supported by the hardware / browser.
+ * @param engine defines the reference to the engine to configure the texture format to use.
+ * @see `@babylonjs/core/Engines/Extensions/engine.textureSelector.d.ts` for more information.
+ */
+export declare function configureEngineToUseCompressedTextures(engine: Engine): void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "babylonjs-editor-tools",
-    "version": "0.0.10",
+    "version": "0.0.11",
     "description": "Babylon.js Editor Tools is a set of tools to help you create, edit and manage your Babylon.js scenes made using the Babylon.JS Editor",
     "productName": "Babylon.js Editor Tools",
     "scripts": {
@@ -17,7 +17,7 @@
             "require": "./build/index.node.js"
         }
     },
-    "typings": "declaration/index.ts",
+    "typings": "declaration/src/index.ts",
     "license": "(Apache-2.0)",
     "devDependencies": {
         "@babel/core": "^7.26.10",