babylonjs-editor-tools 0.0.9 → 0.0.11

package/build/index.node.js

@@ -22,6 +22,8 @@ var index_exports = {};
 __export(index_exports, {
   animationGroupFromScene: () => animationGroupFromScene,
   configureEngineToUseCompressedTextures: () => configureEngineToUseCompressedTextures,
+  configureShadowMapRefreshRate: () => configureShadowMapRefreshRate,
+  configureShadowMapRenderListPredicate: () => configureShadowMapRenderListPredicate,
   createDefaultRenderingPipeline: () => createDefaultRenderingPipeline,
   createMotionBlurPostProcess: () => createMotionBlurPostProcess,
   createSSAO2RenderingPipeline: () => createSSAO2RenderingPipeline,
@@ -36,10 +38,25 @@ __export(index_exports, {
   generateCinematicAnimationGroup: () => generateCinematicAnimationGroup,
   getDefaultRenderingPipeline: () => getDefaultRenderingPipeline,
   getMotionBlurPostProcess: () => getMotionBlurPostProcess,
+  getPowerOfTwoUntil: () => getPowerOfTwoUntil,
   getSSAO2RenderingPipeline: () => getSSAO2RenderingPipeline,
   getSSRRenderingPipeline: () => getSSRRenderingPipeline,
   getVLSPostProcess: () => getVLSPostProcess,
   guiFromAsset: () => guiFromAsset,
+  isAbstractMesh: () => isAbstractMesh,
+  isArcRotateCamera: () => isArcRotateCamera,
+  isBone: () => isBone,
+  isCamera: () => isCamera,
+  isDirectionalLight: () => isDirectionalLight,
+  isFreeCamera: () => isFreeCamera,
+  isGroundMesh: () => isGroundMesh,
+  isHemisphericLight: () => isHemisphericLight,
+  isInstancedMesh: () => isInstancedMesh,
+  isMesh: () => isMesh,
+  isPointLight: () => isPointLight,
+  isSpotLight: () => isSpotLight,
+  isTexture: () => isTexture,
+  isTransformNode: () => isTransformNode,
   loadScene: () => loadScene,
   motionBlurPostProcessCameraConfigurations: () => motionBlurPostProcessCameraConfigurations,
   nodeFromDescendants: () => nodeFromDescendants,
@@ -71,6 +88,17 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/tools/guards.ts
+function isAbstractMesh(object) {
+  switch (object.getClassName?.()) {
+    case "Mesh":
+    case "LineMesh":
+    case "GroundMesh":
+    case "InstancedMesh":
+      return true;
+  }
+  return false;
+}
+__name(isAbstractMesh, "isAbstractMesh");
 function isMesh(object) {
   switch (object.getClassName?.()) {
     case "Mesh":
@@ -80,17 +108,71 @@ function isMesh(object) {
   return false;
 }
 __name(isMesh, "isMesh");
+function isInstancedMesh(object) {
+  return object.getClassName?.() === "InstancedMesh";
+}
+__name(isInstancedMesh, "isInstancedMesh");
+function isBone(object) {
+  return object.getClassName?.() === "Bone";
+}
+__name(isBone, "isBone");
 function isGroundMesh(object) {
   return object.getClassName?.() === "GroundMesh";
 }
 __name(isGroundMesh, "isGroundMesh");
+function isTransformNode(object) {
+  return object.getClassName?.() === "TransformNode";
+}
+__name(isTransformNode, "isTransformNode");
 function isTexture(object) {
   return object?.getClassName?.() === "Texture";
 }
 __name(isTexture, "isTexture");
+function isCamera(object) {
+  switch (object.getClassName?.()) {
+    case "Camera":
+    case "FreeCamera":
+    case "TargetCamera":
+    case "EditorCamera":
+    case "ArcRotateCamera":
+    case "UniversalCamera":
+      return true;
+  }
+  return false;
+}
+__name(isCamera, "isCamera");
+function isFreeCamera(object) {
+  switch (object.getClassName?.()) {
+    case "FreeCamera":
+    case "UniversalCamera":
+      return true;
+  }
+  return false;
+}
+__name(isFreeCamera, "isFreeCamera");
+function isArcRotateCamera(object) {
+  return object.getClassName?.() === "ArcRotateCamera";
+}
+__name(isArcRotateCamera, "isArcRotateCamera");
+function isPointLight(object) {
+  return object.getClassName?.() === "PointLight";
+}
+__name(isPointLight, "isPointLight");
+function isDirectionalLight(object) {
+  return object.getClassName?.() === "DirectionalLight";
+}
+__name(isDirectionalLight, "isDirectionalLight");
+function isSpotLight(object) {
+  return object.getClassName?.() === "SpotLight";
+}
+__name(isSpotLight, "isSpotLight");
+function isHemisphericLight(object) {
+  return object.getClassName?.() === "HemisphericLight";
+}
+__name(isHemisphericLight, "isHemisphericLight");
 
 // src/decorators/apply.ts
-var import_babylonjs6 = require("babylonjs");
+var import_babylonjs16 = require("babylonjs");
 var import_babylonjs_gui = require("babylonjs-gui");
 function applyDecorators(scene, object, script, instance, rootUrl) {
   const ctor = instance.constructor;
@@ -142,10 +224,10 @@ function applyDecorators(scene, object, script, instance, rootUrl) {
           instance[propertyKey] = value;
           break;
         case "vector2":
-          instance[propertyKey] = import_babylonjs6.Vector2.FromArray(value);
+          instance[propertyKey] = import_babylonjs16.Vector2.FromArray(value);
           break;
         case "vector3":
-          instance[propertyKey] = import_babylonjs6.Vector3.FromArray(value);
+          instance[propertyKey] = import_babylonjs16.Vector3.FromArray(value);
           break;
       }
     }
@@ -189,34 +271,41 @@ function applyScriptForObject(scene, object, scriptsMap, rootUrl) {
 __name(applyScriptForObject, "applyScriptForObject");
 
 // src/loading/physics.ts
-var import_babylonjs9 = require("babylonjs");
-var import_babylonjs10 = require("babylonjs");
-function configurePhysicsAggregate(mesh) {
-  const data = mesh.metadata?.physicsAggregate;
+var import_babylonjs20 = require("babylonjs");
+var import_babylonjs21 = require("babylonjs");
+function configurePhysicsAggregate(transformNode) {
+  const data = transformNode.metadata?.physicsAggregate;
   if (!data) {
     return;
   }
-  const aggregate = new import_babylonjs10.PhysicsAggregate(mesh, data.shape.type, {
-    mass: data.massProperties.mass,
-    mesh: isMesh(mesh) ? mesh : void 0
+  let mesh = void 0;
+  if (isMesh(transformNode)) {
+    mesh = transformNode;
+  } else if (isInstancedMesh(transformNode)) {
+    mesh = transformNode.sourceMesh;
+  }
+  const aggregate = new import_babylonjs21.PhysicsAggregate(transformNode, data.shape.type, {
+    mesh,
+    mass: data.massProperties.mass
   });
   aggregate.body.setMassProperties({
     mass: data.massProperties.mass,
-    inertia: data.massProperties.inertia ? import_babylonjs9.Vector3.FromArray(data.massProperties.inertia) : void 0,
-    centerOfMass: data.massProperties.centerOfMass ? import_babylonjs9.Vector3.FromArray(data.massProperties.centerOfMass) : void 0,
-    inertiaOrientation: data.massProperties.inertiaOrientation ? import_babylonjs9.Quaternion.FromArray(data.massProperties.inertiaOrientation) : void 0
+    inertia: data.massProperties.inertia ? import_babylonjs20.Vector3.FromArray(data.massProperties.inertia) : void 0,
+    centerOfMass: data.massProperties.centerOfMass ? import_babylonjs20.Vector3.FromArray(data.massProperties.centerOfMass) : void 0,
+    inertiaOrientation: data.massProperties.inertiaOrientation ? import_babylonjs20.Quaternion.FromArray(data.massProperties.inertiaOrientation) : void 0
   });
   aggregate.shape.density = data.shape.density;
   aggregate.body.setMotionType(data.body.motionType);
   aggregate.shape.material = data.material;
-  mesh.metadata.physicsAggregate = void 0;
+  transformNode.physicsAggregate = aggregate;
+  transformNode.metadata.physicsAggregate = void 0;
 }
 __name(configurePhysicsAggregate, "configurePhysicsAggregate");
 
 // src/rendering/vls.ts
-var import_babylonjs14 = require("babylonjs");
-var import_babylonjs15 = require("babylonjs");
-var import_babylonjs16 = require("babylonjs");
+var import_babylonjs25 = require("babylonjs");
+var import_babylonjs26 = require("babylonjs");
+var import_babylonjs27 = require("babylonjs");
 var vlsPostProcess = null;
 var vlsPostProcessCameraConfigurations = /* @__PURE__ */ new Map();
 function getVLSPostProcess() {
@@ -232,7 +321,7 @@ function disposeVLSPostProcess(scene) {
 __name(disposeVLSPostProcess, "disposeVLSPostProcess");
 function createVLSPostProcess(scene, mesh) {
   mesh ??= scene.meshes.find((mesh2) => isMesh(mesh2));
-  vlsPostProcess = new import_babylonjs16.VolumetricLightScatteringPostProcess("VolumetricLightScatteringPostProcess", 1, scene.activeCamera, mesh, 100, import_babylonjs15.Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false);
+  vlsPostProcess = new import_babylonjs27.VolumetricLightScatteringPostProcess("VolumetricLightScatteringPostProcess", 1, scene.activeCamera, mesh, 100, import_babylonjs26.Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false);
   return vlsPostProcess;
 }
 __name(createVLSPostProcess, "createVLSPostProcess");
@@ -267,13 +356,13 @@ function parseVLSPostProcess(scene, data) {
   vlsPostProcess2.density = data.density;
   vlsPostProcess2.invert = data.invert;
   vlsPostProcess2.useCustomMeshPosition = data.useCustomMeshPosition;
-  vlsPostProcess2.customMeshPosition.copyFrom(import_babylonjs14.Vector3.FromArray(data.customMeshPosition));
+  vlsPostProcess2.customMeshPosition.copyFrom(import_babylonjs25.Vector3.FromArray(data.customMeshPosition));
   return vlsPostProcess2;
 }
 __name(parseVLSPostProcess, "parseVLSPostProcess");
 
 // src/rendering/ssr.ts
-var import_babylonjs19 = require("babylonjs");
+var import_babylonjs30 = require("babylonjs");
 var ssrRenderingPipeline = null;
 var ssrRenderingPipelineCameraConfigurations = /* @__PURE__ */ new Map();
 function getSSRRenderingPipeline() {
@@ -288,7 +377,7 @@ function disposeSSRRenderingPipeline() {
 }
 __name(disposeSSRRenderingPipeline, "disposeSSRRenderingPipeline");
 function createSSRRenderingPipeline(scene, camera) {
-  ssrRenderingPipeline = new import_babylonjs19.SSRRenderingPipeline("SSRRenderingPipeline", scene, [camera]);
+  ssrRenderingPipeline = new import_babylonjs30.SSRRenderingPipeline("SSRRenderingPipeline", scene, [camera]);
   ssrRenderingPipeline.samples = 4;
   return ssrRenderingPipeline;
 }
@@ -353,7 +442,7 @@ function parseSSRRenderingPipeline(scene, camera, data) {
 __name(parseSSRRenderingPipeline, "parseSSRRenderingPipeline");
 
 // src/rendering/ssao.ts
-var import_babylonjs22 = require("babylonjs");
+var import_babylonjs33 = require("babylonjs");
 var ssaoRenderingPipeline = null;
 var ssaoRenderingPipelineCameraConfigurations = /* @__PURE__ */ new Map();
 function getSSAO2RenderingPipeline() {
@@ -368,7 +457,7 @@ function disposeSSAO2RenderingPipeline() {
 }
 __name(disposeSSAO2RenderingPipeline, "disposeSSAO2RenderingPipeline");
 function createSSAO2RenderingPipeline(scene, camera) {
-  ssaoRenderingPipeline = new import_babylonjs22.SSAO2RenderingPipeline("SSAO2RenderingPipeline", scene, 1, [camera]);
+  ssaoRenderingPipeline = new import_babylonjs33.SSAO2RenderingPipeline("SSAO2RenderingPipeline", scene, 1, [camera]);
   ssaoRenderingPipeline.samples = 4;
   return ssaoRenderingPipeline;
 }
@@ -415,7 +504,7 @@ function parseSSAO2RenderingPipeline(scene, camera, data) {
 __name(parseSSAO2RenderingPipeline, "parseSSAO2RenderingPipeline");
 
 // src/rendering/motion-blur.ts
-var import_babylonjs25 = require("babylonjs");
+var import_babylonjs36 = require("babylonjs");
 var motionBlurPostProcess = null;
 var motionBlurPostProcessCameraConfigurations = /* @__PURE__ */ new Map();
 function getMotionBlurPostProcess() {
@@ -430,7 +519,7 @@ function disposeMotionBlurPostProcess() {
 }
 __name(disposeMotionBlurPostProcess, "disposeMotionBlurPostProcess");
 function createMotionBlurPostProcess(scene, camera) {
-  motionBlurPostProcess = new import_babylonjs25.MotionBlurPostProcess("MotionBlurPostProcess", scene, 1, camera);
+  motionBlurPostProcess = new import_babylonjs36.MotionBlurPostProcess("MotionBlurPostProcess", scene, 1, camera);
   motionBlurPostProcess.motionStrength = 1;
   motionBlurPostProcess.isObjectBased = true;
   return motionBlurPostProcess;
@@ -460,9 +549,9 @@ function parseMotionBlurPostProcess(scene, camera, data) {
 __name(parseMotionBlurPostProcess, "parseMotionBlurPostProcess");
 
 // src/rendering/default-pipeline.ts
-var import_babylonjs28 = require("babylonjs");
-var import_babylonjs29 = require("babylonjs");
-var import_babylonjs30 = require("babylonjs");
+var import_babylonjs39 = require("babylonjs");
+var import_babylonjs40 = require("babylonjs");
+var import_babylonjs41 = require("babylonjs");
 var defaultRenderingPipeline = null;
 var defaultPipelineCameraConfigurations = /* @__PURE__ */ new Map();
 function getDefaultRenderingPipeline() {
@@ -477,7 +566,7 @@ function disposeDefaultRenderingPipeline() {
 }
 __name(disposeDefaultRenderingPipeline, "disposeDefaultRenderingPipeline");
 function createDefaultRenderingPipeline(scene, camera) {
-  defaultRenderingPipeline = new import_babylonjs30.DefaultRenderingPipeline("DefaultRenderingPipeline", true, scene, [camera]);
+  defaultRenderingPipeline = new import_babylonjs41.DefaultRenderingPipeline("DefaultRenderingPipeline", true, scene, [camera]);
   defaultRenderingPipeline.samples = 4;
   defaultRenderingPipeline.depthOfField.lensSize = 512;
   defaultRenderingPipeline.depthOfField.fStop = 0.25;
@@ -549,7 +638,7 @@ function parseDefaultRenderingPipeline(scene, camera, data) {
     pipeline.imageProcessing.ditheringEnabled = data.ditheringEnabled;
     pipeline.imageProcessing.ditheringIntensity = data.ditheringIntensity;
     pipeline.imageProcessing.vignetteEnabled = data.vignetteEnabled ?? false;
-    pipeline.imageProcessing.vignetteColor = import_babylonjs28.Color4.FromArray(data.vignetteColor ?? [0, 0, 0]);
+    pipeline.imageProcessing.vignetteColor = import_babylonjs39.Color4.FromArray(data.vignetteColor ?? [0, 0, 0]);
     pipeline.imageProcessing.vignetteWeight = data.vignetteWeight ?? 0.3;
   }
   pipeline.bloomEnabled = data.bloomEnabled;
@@ -572,8 +661,8 @@ function parseDefaultRenderingPipeline(scene, camera, data) {
   pipeline.chromaticAberrationEnabled = data.chromaticAberrationEnabled ?? false;
   pipeline.chromaticAberration.aberrationAmount = data.aberrationAmount ?? 10;
   pipeline.chromaticAberration.radialIntensity = data.radialIntensity ?? 1;
-  pipeline.chromaticAberration.direction = import_babylonjs29.Vector2.FromArray(data.direction ?? [0, 0]);
-  pipeline.chromaticAberration.centerPosition = import_babylonjs29.Vector2.FromArray(data.centerPosition ?? [0, 0]);
+  pipeline.chromaticAberration.direction = import_babylonjs40.Vector2.FromArray(data.direction ?? [0, 0]);
+  pipeline.chromaticAberration.centerPosition = import_babylonjs40.Vector2.FromArray(data.centerPosition ?? [0, 0]);
   pipeline.glowLayerEnabled = data.glowLayerEnabled ?? false;
   if (pipeline.glowLayer) {
     pipeline.glowLayer.intensity = data.glowLayerIntensity ?? 1;
@@ -649,8 +738,8 @@ function applyRenderingConfigurationForCamera(camera) {
 __name(applyRenderingConfigurationForCamera, "applyRenderingConfigurationForCamera");
 
 // src/tools/light.ts
-var import_babylonjs34 = require("babylonjs");
-var import_babylonjs35 = require("babylonjs");
+var import_babylonjs45 = require("babylonjs");
+var import_babylonjs46 = require("babylonjs");
 function configureShadowMapRenderListPredicate(scene) {
   scene.lights.forEach((light) => {
     const shadowMap = light.getShadowGenerator()?.getShadowMap();
@@ -658,7 +747,7 @@ function configureShadowMapRenderListPredicate(scene) {
       return;
     }
     shadowMap.renderListPredicate = (mesh) => {
-      const distance = import_babylonjs34.Vector3.Distance(mesh.getAbsolutePosition(), light.getAbsolutePosition());
+      const distance = import_babylonjs45.Vector3.Distance(mesh.getAbsolutePosition(), light.getAbsolutePosition());
       return distance <= light.range;
     };
   });
@@ -669,7 +758,7 @@ async function configureShadowMapRefreshRate(scene) {
     scene.lights.forEach((light) => {
       const shadowMap = light.getShadowGenerator()?.getShadowMap();
       if (shadowMap) {
-        shadowMap.refreshRate = light.metadata?.refreshRate ?? import_babylonjs35.RenderTargetTexture.REFRESHRATE_RENDER_ONEVERYFRAME;
+        shadowMap.refreshRate = light.metadata?.refreshRate ?? import_babylonjs46.RenderTargetTexture.REFRESHRATE_RENDER_ONEVERYFRAME;
       }
     });
   });
@@ -677,10 +766,10 @@ async function configureShadowMapRefreshRate(scene) {
 __name(configureShadowMapRefreshRate, "configureShadowMapRefreshRate");
 
 // src/loading/sound.ts
-var import_babylonjs38 = require("babylonjs");
-var import_babylonjs39 = require("babylonjs");
-var audioParser = (0, import_babylonjs39.GetParser)(import_babylonjs38.SceneComponentConstants.NAME_AUDIO);
-(0, import_babylonjs39.AddParser)(import_babylonjs38.SceneComponentConstants.NAME_AUDIO, (parsedData, scene, container, rootUrl) => {
+var import_babylonjs49 = require("babylonjs");
+var import_babylonjs50 = require("babylonjs");
+var audioParser = (0, import_babylonjs50.GetParser)(import_babylonjs49.SceneComponentConstants.NAME_AUDIO);
+(0, import_babylonjs50.AddParser)(import_babylonjs49.SceneComponentConstants.NAME_AUDIO, (parsedData, scene, container, rootUrl) => {
   audioParser?.(parsedData, scene, container, rootUrl);
   parsedData.sounds?.forEach((sound) => {
     const instance = container.sounds?.find((s) => s.name === sound.name);
@@ -702,9 +791,9 @@ function getPowerOfTwoUntil(limit) {
 __name(getPowerOfTwoUntil, "getPowerOfTwoUntil");
 
 // src/loading/texture.ts
-var import_babylonjs43 = require("babylonjs");
-var textureParser = import_babylonjs43.SerializationHelper._TextureParser;
-import_babylonjs43.SerializationHelper._TextureParser = (sourceProperty, scene, rootUrl) => {
+var import_babylonjs54 = require("babylonjs");
+var textureParser = import_babylonjs54.SerializationHelper._TextureParser;
+import_babylonjs54.SerializationHelper._TextureParser = (sourceProperty, scene, rootUrl) => {
   if (scene.loadingQuality === "high" || !sourceProperty.metadata?.baseSize) {
     return textureParser(sourceProperty, scene, rootUrl);
   }
@@ -750,18 +839,19 @@ import_babylonjs43.SerializationHelper._TextureParser = (sourceProperty, scene,
 };
 
 // src/loading/loader.ts
-var import_babylonjs45 = require("babylonjs");
-var import_babylonjs46 = require("babylonjs");
+var import_babylonjs56 = require("babylonjs");
+var import_babylonjs57 = require("babylonjs");
+var import_babylonjs58 = require("babylonjs");
 async function loadScene(rootUrl, sceneFilename, scene, scriptsMap, options) {
   scene.loadingQuality = options?.quality ?? "high";
-  await (0, import_babylonjs45.AppendSceneAsync)(`${rootUrl}${sceneFilename}`, scene, {
+  await (0, import_babylonjs57.AppendSceneAsync)(`${rootUrl}${sceneFilename}`, scene, {
     pluginExtension: ".babylon",
     onProgress: /* @__PURE__ */ __name((event) => {
       const progress = Math.min(event.loaded / event.total * 0.5);
       options?.onProgress?.(progress);
     }, "onProgress")
   });
-  if (import_babylonjs46.SceneLoaderFlags.ForceFullSceneLoadingForIncremental) {
+  if (import_babylonjs58.SceneLoaderFlags.ForceFullSceneLoadingForIncremental) {
     scene.meshes.forEach((m) => isMesh(m) && m._checkDelayState());
   }
   const waitingItemsCount = scene.getWaitingItemsCount();
@@ -781,6 +871,9 @@ async function loadScene(rootUrl, sceneFilename, scene, scriptsMap, options) {
       applyRenderingConfigurationForCamera(scene.activeCamera);
     }
   }
+  if (scene.metadata?.physicsGravity) {
+    scene.getPhysicsEngine()?.setGravity(import_babylonjs56.Vector3.FromArray(scene.metadata?.physicsGravity));
+  }
   applyScriptForObject(scene, scene, scriptsMap, rootUrl);
   scene.transformNodes.forEach((transformNode) => {
     applyScriptForObject(scene, transformNode, scriptsMap, rootUrl);
@@ -974,14 +1067,14 @@ function getSoundById(id, scene) {
 __name(getSoundById, "getSoundById");
 
 // src/cinematic/tools.ts
-var import_babylonjs49 = require("babylonjs");
-var import_babylonjs50 = require("babylonjs");
-var import_babylonjs51 = require("babylonjs");
-var import_babylonjs53 = require("babylonjs");
+var import_babylonjs61 = require("babylonjs");
+var import_babylonjs62 = require("babylonjs");
+var import_babylonjs63 = require("babylonjs");
+var import_babylonjs65 = require("babylonjs");
 function cloneKey(dataType, key) {
   let value;
   switch (dataType) {
-    case import_babylonjs50.Animation.ANIMATIONTYPE_FLOAT:
+    case import_babylonjs62.Animation.ANIMATIONTYPE_FLOAT:
       value = key.value;
       break;
     default:
@@ -992,26 +1085,26 @@ function cloneKey(dataType, key) {
     value,
     frame: key.frame,
     interpolation: key.interpolation,
-    inTangent: dataType === import_babylonjs50.Animation.ANIMATIONTYPE_FLOAT ? key.inTangent : key.inTangent?.clone(),
-    outTangent: dataType === import_babylonjs50.Animation.ANIMATIONTYPE_FLOAT ? key.outTangent : key.outTangent?.clone()
+    inTangent: dataType === import_babylonjs62.Animation.ANIMATIONTYPE_FLOAT ? key.inTangent : key.inTangent?.clone(),
+    outTangent: dataType === import_babylonjs62.Animation.ANIMATIONTYPE_FLOAT ? key.outTangent : key.outTangent?.clone()
   };
 }
 __name(cloneKey, "cloneKey");
 function getAnimationTypeForObject(effectiveProperty) {
   if (!isNaN(parseFloat(effectiveProperty)) && isFinite(effectiveProperty)) {
-    return import_babylonjs50.Animation.ANIMATIONTYPE_FLOAT;
-  } else if (effectiveProperty instanceof import_babylonjs53.Quaternion) {
-    return import_babylonjs50.Animation.ANIMATIONTYPE_QUATERNION;
-  } else if (effectiveProperty instanceof import_babylonjs53.Vector3) {
-    return import_babylonjs50.Animation.ANIMATIONTYPE_VECTOR3;
-  } else if (effectiveProperty instanceof import_babylonjs53.Vector2) {
-    return import_babylonjs50.Animation.ANIMATIONTYPE_VECTOR2;
-  } else if (effectiveProperty instanceof import_babylonjs51.Color3) {
-    return import_babylonjs50.Animation.ANIMATIONTYPE_COLOR3;
-  } else if (effectiveProperty instanceof import_babylonjs51.Color4) {
-    return import_babylonjs50.Animation.ANIMATIONTYPE_COLOR4;
-  } else if (effectiveProperty instanceof import_babylonjs49.Size) {
-    return import_babylonjs50.Animation.ANIMATIONTYPE_SIZE;
+    return import_babylonjs62.Animation.ANIMATIONTYPE_FLOAT;
+  } else if (effectiveProperty instanceof import_babylonjs65.Quaternion) {
+    return import_babylonjs62.Animation.ANIMATIONTYPE_QUATERNION;
+  } else if (effectiveProperty instanceof import_babylonjs65.Vector3) {
+    return import_babylonjs62.Animation.ANIMATIONTYPE_VECTOR3;
+  } else if (effectiveProperty instanceof import_babylonjs65.Vector2) {
+    return import_babylonjs62.Animation.ANIMATIONTYPE_VECTOR2;
+  } else if (effectiveProperty instanceof import_babylonjs63.Color3) {
+    return import_babylonjs62.Animation.ANIMATIONTYPE_COLOR3;
+  } else if (effectiveProperty instanceof import_babylonjs63.Color4) {
+    return import_babylonjs62.Animation.ANIMATIONTYPE_COLOR4;
+  } else if (effectiveProperty instanceof import_babylonjs61.Size) {
+    return import_babylonjs62.Animation.ANIMATIONTYPE_SIZE;
   }
   return null;
 }
@@ -1027,9 +1120,9 @@ function getPropertyValue(object, property) {
 __name(getPropertyValue, "getPropertyValue");
 
 // src/cinematic/parse.ts
-var import_babylonjs56 = require("babylonjs");
-var import_babylonjs57 = require("babylonjs");
-var import_babylonjs58 = require("babylonjs");
+var import_babylonjs68 = require("babylonjs");
+var import_babylonjs69 = require("babylonjs");
+var import_babylonjs70 = require("babylonjs");
 function parseCinematic(data, scene) {
   return {
     name: data.name,
@@ -1102,20 +1195,20 @@ function parseCinematicKeyValue(value, type) {
     return void 0;
   }
   switch (type) {
-    case import_babylonjs56.Animation.ANIMATIONTYPE_FLOAT:
+    case import_babylonjs68.Animation.ANIMATIONTYPE_FLOAT:
       return value;
-    case import_babylonjs56.Animation.ANIMATIONTYPE_VECTOR2:
-      return import_babylonjs58.Vector2.FromArray(value);
-    case import_babylonjs56.Animation.ANIMATIONTYPE_VECTOR3:
-      return import_babylonjs58.Vector3.FromArray(value);
-    case import_babylonjs56.Animation.ANIMATIONTYPE_QUATERNION:
-      return import_babylonjs58.Quaternion.FromArray(value);
-    case import_babylonjs56.Animation.ANIMATIONTYPE_COLOR3:
-      return import_babylonjs57.Color3.FromArray(value);
-    case import_babylonjs56.Animation.ANIMATIONTYPE_COLOR4:
-      return import_babylonjs57.Color4.FromArray(value);
-    case import_babylonjs56.Animation.ANIMATIONTYPE_MATRIX:
-      return import_babylonjs58.Matrix.FromArray(value);
+    case import_babylonjs68.Animation.ANIMATIONTYPE_VECTOR2:
+      return import_babylonjs70.Vector2.FromArray(value);
+    case import_babylonjs68.Animation.ANIMATIONTYPE_VECTOR3:
+      return import_babylonjs70.Vector3.FromArray(value);
+    case import_babylonjs68.Animation.ANIMATIONTYPE_QUATERNION:
+      return import_babylonjs70.Quaternion.FromArray(value);
+    case import_babylonjs68.Animation.ANIMATIONTYPE_COLOR3:
+      return import_babylonjs69.Color3.FromArray(value);
+    case import_babylonjs68.Animation.ANIMATIONTYPE_COLOR4:
+      return import_babylonjs69.Color4.FromArray(value);
+    case import_babylonjs68.Animation.ANIMATIONTYPE_MATRIX:
+      return import_babylonjs70.Matrix.FromArray(value);
   }
 }
 __name(parseCinematicKeyValue, "parseCinematicKeyValue");
@@ -1128,27 +1221,37 @@ function handleSetEnabledEvent(scene, config) {
 __name(handleSetEnabledEvent, "handleSetEnabledEvent");
 
 // src/cinematic/events/apply-impulse.ts
-var import_babylonjs61 = require("babylonjs");
+var import_babylonjs73 = require("babylonjs");
+var zeroVector = import_babylonjs73.Vector3.Zero();
 function handleApplyImpulseEvent(scene, config) {
-  const meshes = config.mesh ? [scene.getNodeById(config.mesh)] : scene.meshes;
+  const force = import_babylonjs73.Vector3.FromArray(config.force);
+  const contactPoint = import_babylonjs73.Vector3.FromArray(config.contactPoint);
+  let meshes = config.mesh ? [scene.getNodeById(config.mesh)] : scene.meshes.filter((m) => m.physicsAggregate);
+  if (config.radius) {
+    meshes = meshes.filter((mesh) => {
+      const centerWorld = mesh.getBoundingInfo().boundingBox.centerWorld;
+      return import_babylonjs73.Vector3.Distance(centerWorld, contactPoint) <= config.radius;
+    });
+  }
   meshes.forEach((mesh) => {
     if (mesh.physicsAggregate?.body) {
-      mesh.physicsAggregate.body.applyImpulse(
-        import_babylonjs61.Vector3.FromArray(config.force),
-        import_babylonjs61.Vector3.FromArray(config.contactPoint)
-      );
+      const direction = contactPoint.subtract(mesh.getBoundingInfo().boundingBox.centerWorld);
+      direction.multiplyInPlace(force);
+      mesh.physicsAggregate.body.setLinearVelocity(zeroVector);
+      mesh.physicsAggregate.body.setAngularVelocity(zeroVector);
+      mesh.physicsAggregate.body.applyImpulse(direction.negateInPlace(), contactPoint);
     }
   });
 }
 __name(handleApplyImpulseEvent, "handleApplyImpulseEvent");
 
 // src/cinematic/generate.ts
-var import_babylonjs65 = require("babylonjs");
-var import_babylonjs67 = require("babylonjs");
-var import_babylonjs69 = require("babylonjs");
-var import_babylonjs70 = require("babylonjs");
+var import_babylonjs76 = require("babylonjs");
+var import_babylonjs78 = require("babylonjs");
+var import_babylonjs80 = require("babylonjs");
+var import_babylonjs81 = require("babylonjs");
 function generateCinematicAnimationGroup(cinematic, scene) {
-  const result = new import_babylonjs70.AnimationGroup(cinematic.name, scene);
+  const result = new import_babylonjs81.AnimationGroup(cinematic.name, scene);
   cinematic.tracks.forEach((track) => {
     const animationGroup = track.animationGroup;
     if (animationGroup) {
@@ -1166,7 +1269,7 @@ function generateCinematicAnimationGroup(cinematic, scene) {
             }
             animation2 = targetedAnimation.animation.clone();
             animation2.setKeys([]);
-            animation2.name = import_babylonjs65.Tools.RandomId();
+            animation2.name = import_babylonjs76.Tools.RandomId();
             animation2.framePerSecond = cinematic.framesPerSecond;
           }
           const keys2 = animation2.getKeys();
@@ -1192,17 +1295,17 @@ function generateCinematicAnimationGroup(cinematic, scene) {
       const dummyObject = {
         dummy: 0
       };
-      const soundAnimation = new import_babylonjs67.Animation(sound.name, "dummy", 60, import_babylonjs67.Animation.ANIMATIONTYPE_FLOAT, import_babylonjs67.Animation.ANIMATIONLOOPMODE_CYCLE, false);
+      const soundAnimation = new import_babylonjs78.Animation(sound.name, "dummy", 60, import_babylonjs78.Animation.ANIMATIONTYPE_FLOAT, import_babylonjs78.Animation.ANIMATIONLOOPMODE_CYCLE, false);
       let maxFrame = 0;
       track.sounds?.forEach((configuration) => {
         const duration = configuration.endFrame - configuration.startFrame;
         maxFrame = Math.max(maxFrame, configuration.frame + duration);
-        soundAnimation.addEvent(new import_babylonjs69.AnimationEvent(configuration.frame, (currentFrame) => {
+        soundAnimation.addEvent(new import_babylonjs80.AnimationEvent(configuration.frame, (currentFrame) => {
           const frameDiff = currentFrame - configuration.frame;
           const offset = (frameDiff + configuration.startFrame) / cinematic.framesPerSecond;
           sound.play(0, offset);
         }, false));
-        soundAnimation.addEvent(new import_babylonjs69.AnimationEvent(configuration.frame + duration, () => {
+        soundAnimation.addEvent(new import_babylonjs80.AnimationEvent(configuration.frame + duration, () => {
           sound.stop();
         }));
       });
@@ -1216,11 +1319,11 @@ function generateCinematicAnimationGroup(cinematic, scene) {
       const dummyObject = {
         dummy: 0
       };
-      const eventsAnimation = new import_babylonjs67.Animation("events", "dummy", 60, import_babylonjs67.Animation.ANIMATIONTYPE_FLOAT, import_babylonjs67.Animation.ANIMATIONLOOPMODE_CYCLE, false);
+      const eventsAnimation = new import_babylonjs78.Animation("events", "dummy", 60, import_babylonjs78.Animation.ANIMATIONTYPE_FLOAT, import_babylonjs78.Animation.ANIMATIONLOOPMODE_CYCLE, false);
       let maxFrame = 0;
       track.keyFrameEvents?.forEach((configuration) => {
         maxFrame = Math.max(maxFrame, configuration.frame);
-        eventsAnimation.addEvent(new import_babylonjs69.AnimationEvent(configuration.frame, () => {
+        eventsAnimation.addEvent(new import_babylonjs80.AnimationEvent(configuration.frame, () => {
           switch (configuration.data?.type) {
             case "set-enabled":
               handleSetEnabledEvent(scene, configuration.data);
@@ -1246,7 +1349,7 @@ function generateCinematicAnimationGroup(cinematic, scene) {
     if (animationType === null) {
       return;
     }
-    const animation = new import_babylonjs67.Animation(track.propertyPath, track.propertyPath, 60, animationType, import_babylonjs67.Animation.ANIMATIONLOOPMODE_CYCLE, false);
+    const animation = new import_babylonjs78.Animation(track.propertyPath, track.propertyPath, 60, animationType, import_babylonjs78.Animation.ANIMATIONLOOPMODE_CYCLE, false);
     const keys = [];
     track.keyFrameAnimations?.forEach((keyFrame) => {
       const animationKey = keyFrame.type === "key" ? keyFrame : null;
@@ -1257,6 +1360,19 @@ function generateCinematicAnimationGroup(cinematic, scene) {
       if (animationKeyCut) {
         keys.push(animationKeyCut.key1);
         keys.push(animationKeyCut.key2);
+        if (isCamera(node) && track.propertyPath === "position") {
+          animation.addEvent(new import_babylonjs80.AnimationEvent(animationKeyCut.key1.frame, () => {
+            const motionBlur = getMotionBlurPostProcess();
+            if (!motionBlur) {
+              return;
+            }
+            let motionStrength = motionBlur.motionStrength;
+            motionBlur.motionStrength = 0;
+            requestAnimationFrame(() => {
+              motionBlur.motionStrength = motionStrength;
+            });
+          }));
+        }
       }
     });
     animation.setKeys(keys);
@@ -1270,6 +1386,8 @@ __name(generateCinematicAnimationGroup, "generateCinematicAnimationGroup");
 0 && (module.exports = {
   animationGroupFromScene,
   configureEngineToUseCompressedTextures,
+  configureShadowMapRefreshRate,
+  configureShadowMapRenderListPredicate,
   createDefaultRenderingPipeline,
   createMotionBlurPostProcess,
   createSSAO2RenderingPipeline,
@@ -1284,10 +1402,25 @@ __name(generateCinematicAnimationGroup, "generateCinematicAnimationGroup");
   generateCinematicAnimationGroup,
   getDefaultRenderingPipeline,
   getMotionBlurPostProcess,
+  getPowerOfTwoUntil,
   getSSAO2RenderingPipeline,
   getSSRRenderingPipeline,
   getVLSPostProcess,
   guiFromAsset,
+  isAbstractMesh,
+  isArcRotateCamera,
+  isBone,
+  isCamera,
+  isDirectionalLight,
+  isFreeCamera,
+  isGroundMesh,
+  isHemisphericLight,
+  isInstancedMesh,
+  isMesh,
+  isPointLight,
+  isSpotLight,
+  isTexture,
+  isTransformNode,
   loadScene,
   motionBlurPostProcessCameraConfigurations,
   nodeFromDescendants,