babylonjs-editor-tools 0.0.11 → 5.0.0

package/build/src/rendering/ssr.js

@@ -7,6 +7,13 @@ export const ssrRenderingPipelineCameraConfigurations = new Map();
 export function getSSRRenderingPipeline() {
     return ssrRenderingPipeline;
 }
+/**
+ * Sets the reference to the ssr rendering pipeline.
+ * @access editor only.
+ */
+export function setSSRRenderingPipelineRef(pipeline) {
+    ssrRenderingPipeline = pipeline;
+}
 export function disposeSSRRenderingPipeline() {
     if (ssrRenderingPipeline) {
         ssrRenderingPipeline.dispose();

package/build/src/rendering/tools.js

@@ -20,8 +20,9 @@ export function saveRenderingConfigurationForCamera(camera) {
  * 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.
+ * @param rootUrl defines the rootUrl that contains all resource files needed by the post-processes (color grading texture, etc.).
  */
-export function applyRenderingConfigurationForCamera(camera) {
+export function applyRenderingConfigurationForCamera(camera, rootUrl) {
     disposeSSAO2RenderingPipeline();
     disposeVLSPostProcess(camera.getScene());
     disposeSSRRenderingPipeline();
@@ -45,7 +46,7 @@ export function applyRenderingConfigurationForCamera(camera) {
     }
     const defaultRenderingPipeline = defaultPipelineCameraConfigurations.get(camera);
     if (defaultRenderingPipeline) {
-        parseDefaultRenderingPipeline(camera.getScene(), camera, defaultRenderingPipeline);
+        parseDefaultRenderingPipeline(camera.getScene(), camera, defaultRenderingPipeline, rootUrl);
     }
 }
 //# sourceMappingURL=tools.js.map

package/build/src/rendering/vls.js

@@ -10,6 +10,13 @@ export const vlsPostProcessCameraConfigurations = new Map();
 export function getVLSPostProcess() {
     return vlsPostProcess;
 }
+/**
+ * Sets the reference to the volumetric light scattering post-process.
+ * @access editor only.
+ */
+export function setVLSPostProcessRef(postProcess) {
+    vlsPostProcess = postProcess;
+}
 export function disposeVLSPostProcess(scene) {
     if (vlsPostProcess && scene.activeCamera) {
         vlsPostProcess.dispose(scene.activeCamera);

package/build/src/tools/animation.js

@@ -0,0 +1,21 @@
+import { Animation } from "@babylonjs/core/Animations/animation";
+/**
+ * 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 function getAnimationTypeForObject(effectiveProperty) {
+    if (!isNaN(parseFloat(effectiveProperty)) && isFinite(effectiveProperty)) {
+        return Animation.ANIMATIONTYPE_FLOAT;
+    }
+    switch (effectiveProperty?.getClassName?.()) {
+        case "Vector2": return Animation.ANIMATIONTYPE_VECTOR2;
+        case "Vector3": return Animation.ANIMATIONTYPE_VECTOR3;
+        case "Quaternion": return Animation.ANIMATIONTYPE_QUATERNION;
+        case "Color3": return Animation.ANIMATIONTYPE_COLOR3;
+        case "Color4": return Animation.ANIMATIONTYPE_COLOR4;
+        case "Size": return Animation.ANIMATIONTYPE_SIZE;
+        case "Matrix": return Animation.ANIMATIONTYPE_MATRIX;
+    }
+    return null;
+}
+//# sourceMappingURL=animation.js.map

package/build/src/tools/guards.js

@@ -122,4 +122,59 @@ export function isSpotLight(object) {
 export function isHemisphericLight(object) {
     return object.getClassName?.() === "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 function isLight(object) {
+    switch (object.getClassName?.()) {
+        case "Light":
+        case "PointLight":
+        case "SpotLight":
+        case "DirectionalLight":
+        case "HemisphericLight":
+            return true;
+    }
+    return false;
+}
+/**
+ * Returns wether or not the given object is a Node.
+ * @param object defines the reference to the object to test its class name.
+ */
+export function isNode(object) {
+    return isAbstractMesh(object) || isTransformNode(object) || isLight(object) || isCamera(object);
+}
+/**
+ * Returns wether or not the given object is a Scene.
+ * @param object defines the reference to the object to test its class name.
+ */
+export function isScene(object) {
+    return object.getClassName?.() === "Scene";
+}
+/**
+ * Returns wether or not the given object is a ParticleSystem.
+ * @param object defines the reference to the object to test its class name.
+ */
+export function isParticleSystem(object) {
+    return object.getClassName?.() === "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 function isGPUParticleSystem(object) {
+    return object.getClassName?.() === "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 function isAnyParticleSystem(object) {
+    switch (object.getClassName?.()) {
+        case "ParticleSystem":
+        case "GPUParticleSystem":
+            return true;
+    }
+    return false;
+}
 //# sourceMappingURL=guards.js.map

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

@@ -1,8 +1,10 @@
 import { Scene } from "@babylonjs/core/scene";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector";
+import { AbstractMesh } from "@babylonjs/core/Meshes/abstractMesh";
 export type SetEnabledEventType = {
-    mesh: string;
+    mesh: AbstractMesh;
     radius: number;
-    force: number[];
-    contactPoint: number[];
+    force: Vector3;
+    contactPoint: Vector3;
 };
 export declare function handleApplyImpulseEvent(scene: Scene, config: SetEnabledEventType): void;

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

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

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

@@ -1,9 +1,18 @@
 import { Scene } from "@babylonjs/core/scene";
 import { AnimationGroup } from "@babylonjs/core/Animations/animationGroup";
 import { ICinematic } from "./typings";
+export type GenerateCinematicAnimationGroupOptions = {
+    /**
+     * Defines wether or not sounds should be ignored when generating the animation group.
+     * This means that no sound will be played during the cinematic playback.
+     * @default false
+     */
+    ignoreSounds?: boolean;
+};
 /**
  * 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.
+ * @param options defines the options to use when generating the animation group.
  */
-export declare function generateCinematicAnimationGroup(cinematic: ICinematic, scene: Scene): AnimationGroup;
+export declare function generateCinematicAnimationGroup(cinematic: ICinematic, scene: Scene, options?: GenerateCinematicAnimationGroupOptions): AnimationGroup;

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

@@ -0,0 +1,6 @@
+import { ICinematicAnimationGroup, ICinematicKey, ICinematicKeyCut, ICinematicKeyEvent, ICinematicSound } from "./typings";
+export declare function isCinematicKey(key: any): key is ICinematicKey;
+export declare function isCinematicKeyCut(key: any): key is ICinematicKeyCut;
+export declare function isCinematicKeyEvent(key: any): key is ICinematicKeyEvent;
+export declare function isCinematicGroup(key: any): key is ICinematicAnimationGroup;
+export declare function isCinematicSound(key: any): key is ICinematicSound;

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

@@ -1,10 +1,5 @@
 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.

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

@@ -6,6 +6,7 @@ export interface ICinematic {
     outputFramesPerSecond: number;
 }
 export interface ICinematicTrack {
+    _id?: string;
     animationGroup?: any;
     animationGroups?: ICinematicAnimationGroup[];
     node?: any;
@@ -42,3 +43,4 @@ export interface ICinematicKeyEvent {
     frame: number;
     data?: any;
 }
+export type CinematicKeyType = ICinematicKey | ICinematicKeyCut | ICinematicAnimationGroup | ICinematicSound | ICinematicKeyEvent;

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

@@ -1,6 +1,7 @@
-export type VisibleInInspectorDecoratorType = "number" | "boolean" | "vector2" | "vector3" | "color3" | "color4";
+export type VisibleInInspectorDecoratorType = "number" | "boolean" | "vector2" | "vector3" | "color3" | "color4" | "entity" | "texture" | "keymap";
 export type VisibleInInspectorDecoratorConfiguration = {
     type: VisibleInInspectorDecoratorType;
+    description?: string;
 };
 /**
  * Makes the decorated property visible in the editor inspector as a boolean.
@@ -8,8 +9,9 @@ export type VisibleInInspectorDecoratorConfiguration = {
  * 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 (description, etc.).
  */
-export declare function visibleAsBoolean(label?: string): (target: any, propertyKey: string | Symbol) => void;
+export declare function visibleAsBoolean(label?: string, configuration?: Omit<VisibleInInspectorDecoratorConfiguration, "type">): (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
@@ -80,3 +82,39 @@ export type VisibleInInspectorDecoratorColor4Configuration = VisibleInInspectorD
     noClamp?: boolean;
     noColorPicker?: boolean;
 };
+/**
+ * Makes the decorated property visible in the editor inspector as an entity.
+ * 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 entityType defines the type of entity to be displayed in the inspector (node, sound, animationGroup or particleSystem).
+ * @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 visibleAsEntity(entityType: VisibleAsEntityType, label?: string, configuration?: Omit<VisibleInInspectorDecoratorEntityConfiguration, "type" | "entityType">): (target: any, propertyKey: string | Symbol) => void;
+export type VisibleAsEntityType = "node" | "sound" | "animationGroup" | "particleSystem";
+export type VisibleInInspectorDecoratorEntityConfiguration = VisibleInInspectorDecoratorConfiguration & {
+    entityType?: VisibleAsEntityType;
+};
+/**
+ * Makes the decorated property visible in the editor inspector as a Texture.
+ * 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 (accept cubes, etc.).
+ */
+export declare function visibleAsTexture(label?: string, configuration?: Omit<VisibleInInspectorDecoratorTextureConfiguration, "type">): (target: any, propertyKey: string | Symbol) => void;
+export type VisibleInInspectorDecoratorTextureConfiguration = VisibleInInspectorDecoratorConfiguration & {
+    acceptCubes?: boolean;
+    onlyCubes?: boolean;
+};
+/**
+ * Makes the decorated property visible in the editor inspector as a KeyMap.
+ * 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 (description, etc.).
+ */
+export declare function visibleAsKeyMap(label?: string, configuration?: Omit<VisibleInInspectorDecoratorConfiguration, "type">): (target: any, propertyKey: string | Symbol) => void;

package/declaration/src/index.d.ts

@@ -1,8 +1,11 @@
 export * from "./loading/loader";
+export * from "./loading/material";
+export * from "./loading/script";
 export * from "./tools/guards";
 export * from "./tools/texture";
 export * from "./tools/light";
 export * from "./tools/scalar";
+export * from "./tools/animation";
 export * from "./rendering/ssao";
 export * from "./rendering/ssr";
 export * from "./rendering/motion-blur";
@@ -17,3 +20,4 @@ export * from "./script";
 export * from "./cinematic/parse";
 export * from "./cinematic/typings";
 export * from "./cinematic/generate";
+export * from "./cinematic/guards";

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

@@ -18,13 +18,23 @@ export type ScriptMap = Record<string, {
 /**
  * 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.
+ * The editor computes automatic "high (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 = {
+    /**
+     * Defines the quality of the scene.
+     * This will affect the quality of textures that will be loaded in terms of dimensions.
+     * The editor computes automatic "high (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.
+     */
     quality?: SceneLoaderQualitySelector;
+    /**
+     * Defines the function called to notify the loading progress in interval [0, 1]
+     */
     onProgress?: (value: number) => void;
 };
 declare module "@babylonjs/core/scene" {

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

@@ -0,0 +1,11 @@
+import { Scene } from "@babylonjs/core/scene";
+import { Material } from "@babylonjs/core/Materials/material";
+/**
+ * Loads the file located at `rootUrl + relativePath` and creates a new material from it.
+ * @param rootUrl defines the absolute root url for the assets. (generally "/scene/")
+ * @param relativePath defines the path relative to `rootUrl` for the material file
+ * @param scene defines the reference to the scene where to add the loaded material.
+ * @returns the reference to the created material.
+ * @example await loadMaterialFromFile<PBRMaterial>("/scene/", "assets/floor.material", scene);
+ */
+export declare function loadMaterialFromFile<T extends Material>(rootUrl: string, relativePath: string, scene: Scene): Promise<T>;

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

@@ -1,3 +1,71 @@
 import { Scene } from "@babylonjs/core/scene";
+import { IScript } from "../script";
 import { ScriptMap } from "./loader";
-export declare function applyScriptForObject(scene: Scene, object: any, scriptsMap: ScriptMap, rootUrl: string): void;
+/**
+ * @internal
+ */
+export declare function _applyScriptsForObject(scene: Scene, object: any, scriptsMap: ScriptMap, rootUrl: string): void;
+export interface IRegisteredScript {
+    /**
+     * Defines the key of the script. Refer to scriptMap.
+     */
+    key: string;
+    /**
+     * Defines the instance of the script that was created while loading the scene.
+     */
+    instance: IScript;
+}
+/**
+ * When a scene is being loaded, scripts that were attached to objects in the scene using the Editor are processed.
+ * This function registers the instance of scripts per object in order to retrieve them later.
+ * @param object defines the object in the scene on which the script is attached to.
+ * @param scriptInstance defines the instance of the script to register.
+ * @param key defines the key of the script. This value is used to identify the script.
+ */
+export declare function registerScriptInstance(object: any, scriptInstance: IScript, key: string): void;
+/**
+ * Returns all the instances of the script attached to the given object that matches the given class type.
+ * The same script can be attached multiple times to the same object. If you ensure that ONLY DISTINCT scripts
+ * are attached to the object, you can use `getScriptByClassForObject` which will return the unique instance for the given object.
+ * @param object defines the reference to the object where the script to retrieve is attached to.
+ * @param classType defines the class of the type to retrieve
+ * @example
+ * import { IScript, getAllScriptsByClassForObject } from "babylonjs-editor-tools";
+ *
+ * class ScriptClass implements IScript {
+ * 	public onStart(): void {
+ * 		const instances = getAllScriptsByClassForObject(mesh, OtherScriptClass);
+ * 		instances.forEach((i) => {
+ * 			i.doSomething();
+ * 		});
+ * 	}
+ * }
+ *
+ * class OtherScriptClass implements IScript {
+ * 	public doSomething(): void {
+ * 		console.log("Doing something!");
+ * 	}
+ * }
+ */
+export declare function getAllScriptsByClassForObject<T>(object: any, classType: T): T[];
+/**
+ * Returns the instance of the script attached to the given object that matches the given class type.
+ * @param object defines the reference to the object where the script to retrieve is attached to.
+ * @param classType defines the class of the type to retrieve
+ * @example
+ * import { IScript, getScriptByClassForObject } from "babylonjs-editor-tools";
+ *
+ * class ScriptClass implements IScript {
+ * 	public onStart(): void {
+ * 		const instance = getScriptByClassForObject(mesh, OtherScriptClass);
+ * 		instance.doSomething();
+ * 	}
+ * }
+ *
+ * class OtherScriptClass implements IScript {
+ * 	public doSomething(): void {
+ * 		console.log("Doing something!");
+ * 	}
+ * }
+ */
+export declare function getScriptByClassForObject<T>(object: any, classType: T): NonNullable<T> | null;

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

@@ -9,7 +9,12 @@ export declare const defaultPipelineCameraConfigurations: Map<Camera, any>;
  * Returns the reference to the default rendering pipeline if exists.
  */
 export declare function getDefaultRenderingPipeline(): DefaultRenderingPipeline | null;
+/**
+ * Sets the reference to the default rendering pipeline.
+ * @access editor only.
+ */
+export declare function setDefaultRenderingPipelineRef(pipeline: DefaultRenderingPipeline | null): void;
 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;
+export declare function parseDefaultRenderingPipeline(scene: Scene, camera: Camera, data: any, rootUrl: string): DefaultRenderingPipeline;

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

@@ -6,6 +6,11 @@ import { MotionBlurPostProcess } from "@babylonjs/core/PostProcesses/motionBlurP
  */
 export declare const motionBlurPostProcessCameraConfigurations: Map<Camera, any>;
 export declare function getMotionBlurPostProcess(): MotionBlurPostProcess | null;
+/**
+ * Sets the reference to the motion blur post-process.
+ * @access editor only.
+ */
+export declare function setMotionBlurPostProcessRef(postProcess: MotionBlurPostProcess | null): void;
 export declare function disposeMotionBlurPostProcess(): void;
 export declare function createMotionBlurPostProcess(scene: Scene, camera: Camera): MotionBlurPostProcess;
 export declare function serializeMotionBlurPostProcess(): any;

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

@@ -6,6 +6,11 @@ import { SSAO2RenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipe
  */
 export declare const ssaoRenderingPipelineCameraConfigurations: Map<Camera, any>;
 export declare function getSSAO2RenderingPipeline(): SSAO2RenderingPipeline | null;
+/**
+ * Sets the reference to the SSAO rendering pipeline.
+ * @access editor only.
+ */
+export declare function setSSAO2RenderingPipelineRef(pipeline: SSAO2RenderingPipeline | null): void;
 export declare function disposeSSAO2RenderingPipeline(): void;
 export declare function createSSAO2RenderingPipeline(scene: Scene, camera: Camera): SSAO2RenderingPipeline;
 export declare function serializeSSAO2RenderingPipeline(): any;

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

@@ -6,6 +6,11 @@ import { SSRRenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipeli
  */
 export declare const ssrRenderingPipelineCameraConfigurations: Map<Camera, any>;
 export declare function getSSRRenderingPipeline(): SSRRenderingPipeline | null;
+/**
+ * Sets the reference to the ssr rendering pipeline.
+ * @access editor only.
+ */
+export declare function setSSRRenderingPipelineRef(pipeline: SSRRenderingPipeline | null): void;
 export declare function disposeSSRRenderingPipeline(): void;
 export declare function createSSRRenderingPipeline(scene: Scene, camera: Camera): SSRRenderingPipeline;
 export declare function serializeSSRRenderingPipeline(): any;

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

@@ -10,5 +10,6 @@ export declare function saveRenderingConfigurationForCamera(camera: Camera): voi
  * 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.
+ * @param rootUrl defines the rootUrl that contains all resource files needed by the post-processes (color grading texture, etc.).
  */
-export declare function applyRenderingConfigurationForCamera(camera: Camera): void;
+export declare function applyRenderingConfigurationForCamera(camera: Camera, rootUrl: string): void;

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

@@ -7,6 +7,11 @@ import { VolumetricLightScatteringPostProcess } from "@babylonjs/core/PostProces
  */
 export declare const vlsPostProcessCameraConfigurations: Map<Camera, any>;
 export declare function getVLSPostProcess(): VolumetricLightScatteringPostProcess | null;
+/**
+ * Sets the reference to the volumetric light scattering post-process.
+ * @access editor only.
+ */
+export declare function setVLSPostProcessRef(postProcess: VolumetricLightScatteringPostProcess | null): void;
 export declare function disposeVLSPostProcess(scene: Scene): void;
 export declare function createVLSPostProcess(scene: Scene, mesh?: Mesh | null): VolumetricLightScatteringPostProcess;
 export declare function serializeVLSPostProcess(): any;

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

@@ -0,0 +1,5 @@
+/**
+ * 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;

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

@@ -1,3 +1,5 @@
+import { Scene } from "@babylonjs/core/scene";
+import { Node } from "@babylonjs/core/node";
 import { Bone } from "@babylonjs/core/Bones/bone";
 import { Mesh } from "@babylonjs/core/Meshes/mesh";
 import { GroundMesh } from "@babylonjs/core/Meshes/groundMesh";
@@ -7,10 +9,14 @@ 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 { Light } from "@babylonjs/core/Lights/light";
 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";
+import { ParticleSystem } from "@babylonjs/core/Particles/particleSystem";
+import { IParticleSystem } from "@babylonjs/core/Particles/IParticleSystem";
+import { GPUParticleSystem } from "@babylonjs/core/Particles/gpuParticleSystem";
 /**
  * Returns wether or not the given object is an AbstractMesh.
  * @param object defines the reference to the object to test its class name.
@@ -81,3 +87,33 @@ export declare function isSpotLight(object: any): object is SpotLight;
  * @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;
+/**
+ * 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 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/package.json

@@ -1,13 +1,13 @@
 {
     "name": "babylonjs-editor-tools",
-    "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",
+    "version": "5.0.0",
+    "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": {
         "build": "tsc -p . && node esbuild.mjs",
         "watch": "concurrently \"tsc -p . --watch\" \"node esbuild.mjs --watch\"",
-        "test": "jest test/*",
-        "coverage": "jest test/* --coverage"
+        "test": "jest build/test/*",
+        "coverage": "jest build/test/* --coverage"
     },
     "main": "build/index.js",
     "exports": {
@@ -17,21 +17,21 @@
             "require": "./build/index.node.js"
         }
     },
-    "typings": "declaration/src/index.ts",
+    "typings": "declaration/src/index.d.ts",
     "license": "(Apache-2.0)",
     "devDependencies": {
         "@babel/core": "^7.26.10",
         "@babel/preset-env": "^7.26.9",
         "@babel/preset-typescript": "^7.27.0",
-        "@babylonjs/core": "8.6.1",
-        "@babylonjs/gui": "8.6.1",
+        "@babylonjs/core": "8.15.1",
+        "@babylonjs/gui": "8.15.1",
         "@types/jest": "^29.5.14",
         "babel-jest": "^29.7.0",
         "babel-plugin-transform-class-properties": "^6.24.1",
         "babel-plugin-transform-decorators-legacy": "^1.3.5",
-        "esbuild": "^0.25.0",
+        "esbuild": "0.25.5",
         "jest": "^29.7.0",
-        "typescript": "5.4.5"
+        "typescript": "5.8.3"
     },
     "dependencies": {}
 }