babylonjs-editor-tools 0.0.10 → 0.0.12

package/build/src/cinematic/events/apply-impulse.js

@@ -1,24 +1,22 @@
 import { Vector3 } from "@babylonjs/core/Maths/math.vector";
 const zeroVector = Vector3.Zero();
 export function handleApplyImpulseEvent(scene, config) {
-    const force = Vector3.FromArray(config.force);
-    const contactPoint = Vector3.FromArray(config.contactPoint);
     let meshes = config.mesh
-        ? [scene.getNodeById(config.mesh)]
+        ? [config.mesh]
         : scene.meshes.filter((m) => m.physicsAggregate);
     if (config.radius) {
         meshes = meshes.filter((mesh) => {
             const centerWorld = mesh.getBoundingInfo().boundingBox.centerWorld;
-            return Vector3.Distance(centerWorld, contactPoint) <= config.radius;
+            return Vector3.Distance(centerWorld, config.contactPoint) <= config.radius;
         });
     }
     meshes.forEach((mesh) => {
         if (mesh.physicsAggregate?.body) {
-            const direction = contactPoint.subtract(mesh.getBoundingInfo().boundingBox.centerWorld);
-            direction.multiplyInPlace(force);
+            const direction = config.contactPoint.subtract(mesh.getBoundingInfo().boundingBox.centerWorld);
+            direction.multiplyInPlace(config.force);
             mesh.physicsAggregate.body.setLinearVelocity(zeroVector);
             mesh.physicsAggregate.body.setAngularVelocity(zeroVector);
-            mesh.physicsAggregate.body.applyImpulse(direction.negateInPlace(), contactPoint);
+            mesh.physicsAggregate.body.applyImpulse(direction.negateInPlace(), config.contactPoint);
         }
     });
 }

package/build/src/cinematic/events/set-enabled.js

@@ -1,5 +1,4 @@
-export function handleSetEnabledEvent(scene, config) {
-    const node = scene.getNodeById(config.node);
-    node?.setEnabled(config.value);
+export function handleSetEnabledEvent(config) {
+    config.node?.setEnabled(config.value);
 }
 //# sourceMappingURL=set-enabled.js.map

package/build/src/cinematic/generate.js

@@ -3,17 +3,19 @@ import { Animation } from "@babylonjs/core/Animations/animation";
 import { AnimationEvent } from "@babylonjs/core/Animations/animationEvent";
 import { AnimationGroup } from "@babylonjs/core/Animations/animationGroup";
 import { isCamera } from "../tools/guards";
+import { getAnimationTypeForObject } from "../tools/animation";
 import { getMotionBlurPostProcess } from "../rendering/motion-blur";
 import { getDefaultRenderingPipeline } from "../rendering/default-pipeline";
 import { handleSetEnabledEvent } from "./events/set-enabled";
 import { handleApplyImpulseEvent } from "./events/apply-impulse";
-import { cloneKey, getAnimationTypeForObject, getPropertyValue } from "./tools";
+import { cloneKey, getPropertyValue } from "./tools";
 /**
  * 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 function generateCinematicAnimationGroup(cinematic, scene) {
+export function generateCinematicAnimationGroup(cinematic, scene, options) {
     const result = new AnimationGroup(cinematic.name, scene);
     cinematic.tracks.forEach((track) => {
         // Animation groups
@@ -55,7 +57,7 @@ export function generateCinematicAnimationGroup(cinematic, scene) {
         }
         const sound = track.sound;
         const soundBuffer = sound?.getAudioBuffer();
-        if (sound && soundBuffer && track.sounds?.length) {
+        if (!options?.ignoreSounds && sound && soundBuffer && track.sounds?.length) {
             const dummyObject = {
                 dummy: 0,
             };
@@ -91,7 +93,7 @@ export function generateCinematicAnimationGroup(cinematic, scene) {
                 eventsAnimation.addEvent(new AnimationEvent(configuration.frame, () => {
                     switch (configuration.data?.type) {
                         case "set-enabled":
-                            handleSetEnabledEvent(scene, configuration.data);
+                            handleSetEnabledEvent(configuration.data);
                             break;
                         case "apply-impulse":
                             handleApplyImpulseEvent(scene, configuration.data);

package/build/src/cinematic/guards.js

@@ -0,0 +1,16 @@
+export function isCinematicKey(key) {
+    return key.type === "key";
+}
+export function isCinematicKeyCut(key) {
+    return key.type === "cut";
+}
+export function isCinematicKeyEvent(key) {
+    return key.type === "event";
+}
+export function isCinematicGroup(key) {
+    return key.type === "group";
+}
+export function isCinematicSound(key) {
+    return key.type === "sound";
+}
+//# sourceMappingURL=guards.js.map

package/build/src/cinematic/parse.js

@@ -3,7 +3,8 @@ import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
 import { Quaternion, Vector2, Vector3, Matrix } from "@babylonjs/core/Maths/math.vector";
 import { getDefaultRenderingPipeline } from "../rendering/default-pipeline";
 import { getSoundById } from "../tools/sound";
-import { getAnimationTypeForObject, getPropertyValue } from "./tools";
+import { getAnimationTypeForObject } from "../tools/animation";
+import { getPropertyValue } from "./tools";
 /**
  * Parses the given JSON data and returns a new cinematic object.
  * @param data defines the JSON data of the cinematic to parse.
@@ -19,6 +20,9 @@ export function parseCinematic(data, scene) {
             let animationType = null;
             if (track.node) {
                 node = scene.getNodeById(track.node);
+                if (!node) {
+                    node = scene.particleSystems?.find((ps) => ps.id === track.node) ?? null;
+                }
             }
             else if (track.defaultRenderingPipeline) {
                 node = getDefaultRenderingPipeline();
@@ -39,7 +43,30 @@ export function parseCinematic(data, scene) {
                 animationGroup: track.animationGroup ? scene.getAnimationGroupByName(track.animationGroup) : null,
                 animationGroups: track.animationGroups,
                 sounds: track.sounds,
-                keyFrameEvents: track.keyFrameEvents,
+                keyFrameEvents: track.keyFrameEvents?.map((event) => {
+                    const result = {
+                        ...event,
+                    };
+                    switch (event.data?.type) {
+                        case "set-enabled":
+                            result.data = {
+                                type: "set-enabled",
+                                value: event.data.value,
+                                node: scene.getNodeById(event.data.node),
+                            };
+                            break;
+                        case "apply-impulse":
+                            result.data = {
+                                type: "apply-impulse",
+                                radius: event.data.radius,
+                                mesh: scene.getMeshById(event.data.mesh),
+                                force: Vector3.FromArray(event.data.force),
+                                contactPoint: Vector3.FromArray(event.data.contactPoint),
+                            };
+                            break;
+                    }
+                    return result;
+                }),
                 keyFrameAnimations: node && animationType !== null && track.keyFrameAnimations?.map((keyFrame) => {
                     const animationKey = keyFrame.type === "key" ? keyFrame : null;
                     if (animationKey) {
@@ -68,6 +95,7 @@ export function parseCinematic(data, scene) {
                             },
                         };
                     }
+                    throw new Error(`Unknown key frame type: ${keyFrame.type}`);
                 }),
             };
         }),

package/build/src/cinematic/tools.js

@@ -1,7 +1,4 @@
-import { Size } from "@babylonjs/core/Maths/math.size";
 import { Animation } from "@babylonjs/core/Animations/animation";
-import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
-import { Quaternion, Vector2, Vector3 } from "@babylonjs/core/Maths/math.vector";
 export function cloneKey(dataType, key) {
     let value;
     switch (dataType) {
@@ -20,34 +17,6 @@ export function cloneKey(dataType, key) {
         outTangent: dataType === Animation.ANIMATIONTYPE_FLOAT ? key.outTangent : key.outTangent?.clone(),
     };
 }
-/**
- * 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;
-    }
-    else if (effectiveProperty instanceof Quaternion) {
-        return Animation.ANIMATIONTYPE_QUATERNION;
-    }
-    else if (effectiveProperty instanceof Vector3) {
-        return Animation.ANIMATIONTYPE_VECTOR3;
-    }
-    else if (effectiveProperty instanceof Vector2) {
-        return Animation.ANIMATIONTYPE_VECTOR2;
-    }
-    else if (effectiveProperty instanceof Color3) {
-        return Animation.ANIMATIONTYPE_COLOR3;
-    }
-    else if (effectiveProperty instanceof Color4) {
-        return Animation.ANIMATIONTYPE_COLOR4;
-    }
-    else if (effectiveProperty instanceof Size) {
-        return Animation.ANIMATIONTYPE_SIZE;
-    }
-    return 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/build/src/decorators/apply.js

@@ -1,5 +1,7 @@
+import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
 import { Vector2, Vector3 } from "@babylonjs/core/Maths/math.vector";
 import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
+import { getSoundById } from "../tools/sound";
 export function applyDecorators(scene, object, script, instance, rootUrl) {
     const ctor = instance.constructor;
     if (!ctor) {
@@ -64,6 +66,29 @@ export function applyDecorators(scene, object, script, instance, rootUrl) {
                 case "vector3":
                     instance[propertyKey] = Vector3.FromArray(value);
                     break;
+                case "color3":
+                    instance[propertyKey] = Color3.FromArray(value);
+                    break;
+                case "color4":
+                    instance[propertyKey] = Color4.FromArray(value);
+                    break;
+                case "entity":
+                    const entityType = params.configuration.entityType;
+                    switch (entityType) {
+                        case "node":
+                            instance[propertyKey] = scene.getNodeById(value) ?? null;
+                            break;
+                        case "animationGroup":
+                            instance[propertyKey] = scene.getAnimationGroupByName(value) ?? null;
+                            break;
+                        case "sound":
+                            instance[propertyKey] = getSoundById(value, scene);
+                            break;
+                        case "particleSystem":
+                            instance[propertyKey] = scene.particleSystems?.find((ps) => ps.id === value) ?? null;
+                            break;
+                    }
+                    break;
             }
         }
     });

package/build/src/decorators/inspector.js

@@ -4,8 +4,9 @@
  * 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 function visibleAsBoolean(label) {
+export function visibleAsBoolean(label, configuration) {
     return function (target, propertyKey) {
         const ctor = target.constructor;
         ctor._VisibleInInspector ??= [];
@@ -13,6 +14,7 @@ export function visibleAsBoolean(label) {
             label,
             propertyKey,
             configuration: {
+                ...configuration,
                 type: "boolean",
             },
         });
@@ -128,4 +130,28 @@ export function visibleAsColor4(label, configuration) {
         });
     };
 }
+/**
+ * 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 function visibleAsEntity(entityType, label, configuration) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        ctor._VisibleInInspector ??= [];
+        ctor._VisibleInInspector.push({
+            label,
+            propertyKey,
+            configuration: {
+                ...configuration,
+                entityType,
+                type: "entity",
+            },
+        });
+    };
+}
 //# sourceMappingURL=inspector.js.map

package/build/src/index.js

@@ -3,6 +3,7 @@ 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,4 +18,5 @@ export * from "./script";
 export * from "./cinematic/parse";
 export * from "./cinematic/typings";
 export * from "./cinematic/generate";
+export * from "./cinematic/guards";
 //# sourceMappingURL=index.js.map

package/build/src/loading/loader.js

@@ -35,7 +35,7 @@ export async function loadScene(rootUrl, sceneFilename, scene, scriptsMap, optio
     if (scene.metadata?.rendering) {
         applyRenderingConfigurations(scene, scene.metadata.rendering);
         if (scene.activeCamera) {
-            applyRenderingConfigurationForCamera(scene.activeCamera);
+            applyRenderingConfigurationForCamera(scene.activeCamera, rootUrl);
         }
     }
     if (scene.metadata?.physicsGravity) {

package/build/src/rendering/default-pipeline.js

@@ -1,6 +1,9 @@
 import { Color4 } from "@babylonjs/core/Maths/math.color";
 import { Vector2 } from "@babylonjs/core/Maths/math.vector";
+import { Texture } from "@babylonjs/core/Materials/Textures/texture";
+import { ColorGradingTexture } from "@babylonjs/core/Materials/Textures/colorGradingTexture";
 import { DefaultRenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/defaultRenderingPipeline";
+import { isTexture } from "../tools/guards";
 let defaultRenderingPipeline = null;
 /**
  * Defines the configuration of the default rendering pipeline per camera.
@@ -12,6 +15,13 @@ export const defaultPipelineCameraConfigurations = new Map();
 export function getDefaultRenderingPipeline() {
     return defaultRenderingPipeline;
 }
+/**
+ * Sets the reference to the default rendering pipeline.
+ * @access editor only.
+ */
+export function setDefaultRenderingPipelineRef(pipeline) {
+    defaultRenderingPipeline = pipeline;
+}
 export function disposeDefaultRenderingPipeline() {
     if (defaultRenderingPipeline) {
         defaultRenderingPipeline.dispose();
@@ -70,9 +80,30 @@ export function serializeDefaultRenderingPipeline() {
         glowLayerEnabled: defaultRenderingPipeline.glowLayerEnabled,
         glowLayerIntensity: defaultRenderingPipeline.glowLayer?.intensity,
         glowLayerBlurKernelSize: defaultRenderingPipeline.glowLayer?.blurKernelSize,
+        // Since v5.0.0-alpha.10
+        colorGradingEnabled: defaultRenderingPipeline.imageProcessing.colorGradingEnabled,
+        colorGradingTexture: defaultRenderingPipeline.imageProcessing.colorGradingTexture?.serialize(),
+        colorGradingWithGreenDepth: defaultRenderingPipeline.imageProcessing.imageProcessingConfiguration.colorGradingWithGreenDepth,
+        colorCurvesEnabled: defaultRenderingPipeline.imageProcessing.colorCurvesEnabled,
+        globalHue: defaultRenderingPipeline.imageProcessing.colorCurves?.globalHue,
+        globalDensity: defaultRenderingPipeline.imageProcessing.colorCurves?.globalDensity,
+        globalExposure: defaultRenderingPipeline.imageProcessing.colorCurves?.globalExposure,
+        globalSaturation: defaultRenderingPipeline.imageProcessing.colorCurves?.globalSaturation,
+        highlightsHue: defaultRenderingPipeline.imageProcessing.colorCurves?.highlightsHue,
+        highlightsDensity: defaultRenderingPipeline.imageProcessing.colorCurves?.highlightsDensity,
+        highlightsExposure: defaultRenderingPipeline.imageProcessing.colorCurves?.highlightsExposure,
+        highlightsSaturation: defaultRenderingPipeline.imageProcessing.colorCurves?.highlightsSaturation,
+        midtonesHue: defaultRenderingPipeline.imageProcessing.colorCurves?.midtonesHue,
+        midtonesDensity: defaultRenderingPipeline.imageProcessing.colorCurves?.midtonesDensity,
+        midtonesExposure: defaultRenderingPipeline.imageProcessing.colorCurves?.midtonesExposure,
+        midtonesSaturation: defaultRenderingPipeline.imageProcessing.colorCurves?.midtonesSaturation,
+        shadowsHue: defaultRenderingPipeline.imageProcessing.colorCurves?.shadowsHue,
+        shadowsDensity: defaultRenderingPipeline.imageProcessing.colorCurves?.shadowsDensity,
+        shadowsExposure: defaultRenderingPipeline.imageProcessing.colorCurves?.shadowsExposure,
+        shadowsSaturation: defaultRenderingPipeline.imageProcessing.colorCurves?.shadowsSaturation,
     };
 }
-export function parseDefaultRenderingPipeline(scene, camera, data) {
+export function parseDefaultRenderingPipeline(scene, camera, data, rootUrl) {
     if (defaultRenderingPipeline) {
         return defaultRenderingPipeline;
     }
@@ -92,6 +123,43 @@ export function parseDefaultRenderingPipeline(scene, camera, data) {
         pipeline.imageProcessing.vignetteEnabled = data.vignetteEnabled ?? false;
         pipeline.imageProcessing.vignetteColor = Color4.FromArray(data.vignetteColor ?? [0, 0, 0]);
         pipeline.imageProcessing.vignetteWeight = data.vignetteWeight ?? 0.3;
+        // Since v5.0.0-alpha.10
+        pipeline.imageProcessing.colorGradingEnabled = data.colorGradingEnabled ?? false;
+        pipeline.imageProcessing.imageProcessingConfiguration.colorGradingWithGreenDepth = data.colorGradingWithGreenDepth ?? true;
+        if (data.colorGradingTexture) {
+            let texture = null;
+            if (data.colorGradingTexture.customType === "BABYLON.ColorGradingTexture") {
+                const absoluteUrl = rootUrl + data.colorGradingTexture.name;
+                texture = new ColorGradingTexture(absoluteUrl, scene);
+                texture.level = data.colorGradingTexture.level;
+            }
+            else {
+                const parsedTexture = Texture.Parse(data.colorGradingTexture, scene, rootUrl);
+                if (isTexture(parsedTexture)) {
+                    texture = parsedTexture;
+                }
+            }
+            pipeline.imageProcessing.colorGradingTexture = texture;
+        }
+        pipeline.imageProcessing.colorCurvesEnabled = data.colorCurvesEnabled ?? false;
+        if (pipeline.imageProcessing.colorCurves) {
+            pipeline.imageProcessing.colorCurves.globalHue = data.globalHue ?? 30;
+            pipeline.imageProcessing.colorCurves.globalDensity = data.globalDensity ?? 0;
+            pipeline.imageProcessing.colorCurves.globalExposure = data.globalExposure ?? 0;
+            pipeline.imageProcessing.colorCurves.globalSaturation = data.globalSaturation ?? 0;
+            pipeline.imageProcessing.colorCurves.highlightsHue = data.highlightsHue ?? 30;
+            pipeline.imageProcessing.colorCurves.highlightsDensity = data.highlightsDensity ?? 0;
+            pipeline.imageProcessing.colorCurves.highlightsExposure = data.highlightsExposure ?? 0;
+            pipeline.imageProcessing.colorCurves.highlightsSaturation = data.highlightsSaturation ?? 0;
+            pipeline.imageProcessing.colorCurves.midtonesHue = data.midtonesHue ?? 30;
+            pipeline.imageProcessing.colorCurves.midtonesDensity = data.midtonesDensity ?? 0;
+            pipeline.imageProcessing.colorCurves.midtonesExposure = data.midtonesExposure ?? 0;
+            pipeline.imageProcessing.colorCurves.midtonesSaturation = data.midtonesSaturation ?? 0;
+            pipeline.imageProcessing.colorCurves.shadowsHue = data.shadowsHue ?? 30;
+            pipeline.imageProcessing.colorCurves.shadowsDensity = data.shadowsDensity ?? 0;
+            pipeline.imageProcessing.colorCurves.shadowsExposure = data.shadowsExposure ?? 0;
+            pipeline.imageProcessing.colorCurves.shadowsSaturation = data.shadowsSaturation ?? 0;
+        }
     }
     pipeline.bloomEnabled = data.bloomEnabled;
     pipeline.bloomThreshold = data.bloomThreshold;

package/build/src/rendering/motion-blur.js

@@ -7,6 +7,13 @@ export const motionBlurPostProcessCameraConfigurations = new Map();
 export function getMotionBlurPostProcess() {
     return motionBlurPostProcess;
 }
+/**
+ * Sets the reference to the motion blur post-process.
+ * @access editor only.
+ */
+export function setMotionBlurPostProcessRef(postProcess) {
+    motionBlurPostProcess = postProcess;
+}
 export function disposeMotionBlurPostProcess() {
     if (motionBlurPostProcess) {
         motionBlurPostProcess.dispose();

package/build/src/rendering/ssao.js

@@ -7,6 +7,13 @@ export const ssaoRenderingPipelineCameraConfigurations = new Map();
 export function getSSAO2RenderingPipeline() {
     return ssaoRenderingPipeline;
 }
+/**
+ * Sets the reference to the SSAO rendering pipeline.
+ * @access editor only.
+ */
+export function setSSAO2RenderingPipelineRef(pipeline) {
+    ssaoRenderingPipeline = pipeline;
+}
 export function disposeSSAO2RenderingPipeline() {
     if (ssaoRenderingPipeline) {
         ssaoRenderingPipeline.dispose();

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/declaration/src/cinematic/events/apply-impulse.d.ts

@@ -0,0 +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: AbstractMesh;
+    radius: number;
+    force: Vector3;
+    contactPoint: Vector3;
+};
+export declare function handleApplyImpulseEvent(scene: Scene, config: SetEnabledEventType): void;

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

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

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

@@ -0,0 +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, 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/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,10 @@
+import { IAnimationKey } from "@babylonjs/core/Animations/animationKey";
+export declare function cloneKey(dataType: number, key: IAnimationKey): IAnimationKey;
+/**
+ * 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,46 @@
+import { IAnimationKey } from "@babylonjs/core/Animations/animationKey";
+export interface ICinematic {
+    name: string;
+    framesPerSecond: number;
+    tracks: ICinematicTrack[];
+    outputFramesPerSecond: number;
+}
+export interface ICinematicTrack {
+    _id?: string;
+    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;
+}
+export type CinematicKeyType = ICinematicKey | ICinematicKeyCut | ICinematicAnimationGroup | ICinematicSound | ICinematicKeyEvent;