babylonjs-editor-tools 0.0.8 → 0.0.9

package/build/index.node.js

@@ -0,0 +1,1318 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  animationGroupFromScene: () => animationGroupFromScene,
+  configureEngineToUseCompressedTextures: () => configureEngineToUseCompressedTextures,
+  createDefaultRenderingPipeline: () => createDefaultRenderingPipeline,
+  createMotionBlurPostProcess: () => createMotionBlurPostProcess,
+  createSSAO2RenderingPipeline: () => createSSAO2RenderingPipeline,
+  createSSRRenderingPipeline: () => createSSRRenderingPipeline,
+  createVLSPostProcess: () => createVLSPostProcess,
+  defaultPipelineCameraConfigurations: () => defaultPipelineCameraConfigurations,
+  disposeDefaultRenderingPipeline: () => disposeDefaultRenderingPipeline,
+  disposeMotionBlurPostProcess: () => disposeMotionBlurPostProcess,
+  disposeSSAO2RenderingPipeline: () => disposeSSAO2RenderingPipeline,
+  disposeSSRRenderingPipeline: () => disposeSSRRenderingPipeline,
+  disposeVLSPostProcess: () => disposeVLSPostProcess,
+  generateCinematicAnimationGroup: () => generateCinematicAnimationGroup,
+  getDefaultRenderingPipeline: () => getDefaultRenderingPipeline,
+  getMotionBlurPostProcess: () => getMotionBlurPostProcess,
+  getSSAO2RenderingPipeline: () => getSSAO2RenderingPipeline,
+  getSSRRenderingPipeline: () => getSSRRenderingPipeline,
+  getVLSPostProcess: () => getVLSPostProcess,
+  guiFromAsset: () => guiFromAsset,
+  loadScene: () => loadScene,
+  motionBlurPostProcessCameraConfigurations: () => motionBlurPostProcessCameraConfigurations,
+  nodeFromDescendants: () => nodeFromDescendants,
+  nodeFromScene: () => nodeFromScene,
+  parseCinematic: () => parseCinematic,
+  parseCinematicKeyValue: () => parseCinematicKeyValue,
+  parseDefaultRenderingPipeline: () => parseDefaultRenderingPipeline,
+  parseMotionBlurPostProcess: () => parseMotionBlurPostProcess,
+  parseSSAO2RenderingPipeline: () => parseSSAO2RenderingPipeline,
+  parseSSRRenderingPipeline: () => parseSSRRenderingPipeline,
+  parseVLSPostProcess: () => parseVLSPostProcess,
+  particleSystemFromScene: () => particleSystemFromScene,
+  serializeDefaultRenderingPipeline: () => serializeDefaultRenderingPipeline,
+  serializeMotionBlurPostProcess: () => serializeMotionBlurPostProcess,
+  serializeSSAO2RenderingPipeline: () => serializeSSAO2RenderingPipeline,
+  serializeSSRRenderingPipeline: () => serializeSSRRenderingPipeline,
+  serializeVLSPostProcess: () => serializeVLSPostProcess,
+  soundFromScene: () => soundFromScene,
+  ssaoRenderingPipelineCameraConfigurations: () => ssaoRenderingPipelineCameraConfigurations,
+  ssrRenderingPipelineCameraConfigurations: () => ssrRenderingPipelineCameraConfigurations,
+  visibleAsBoolean: () => visibleAsBoolean,
+  visibleAsColor3: () => visibleAsColor3,
+  visibleAsColor4: () => visibleAsColor4,
+  visibleAsNumber: () => visibleAsNumber,
+  visibleAsVector2: () => visibleAsVector2,
+  visibleAsVector3: () => visibleAsVector3,
+  vlsPostProcessCameraConfigurations: () => vlsPostProcessCameraConfigurations
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/tools/guards.ts
+function isMesh(object) {
+  switch (object.getClassName?.()) {
+    case "Mesh":
+    case "GroundMesh":
+      return true;
+  }
+  return false;
+}
+__name(isMesh, "isMesh");
+function isGroundMesh(object) {
+  return object.getClassName?.() === "GroundMesh";
+}
+__name(isGroundMesh, "isGroundMesh");
+function isTexture(object) {
+  return object?.getClassName?.() === "Texture";
+}
+__name(isTexture, "isTexture");
+
+// src/decorators/apply.ts
+var import_babylonjs6 = require("babylonjs");
+var import_babylonjs_gui = require("babylonjs-gui");
+function applyDecorators(scene, object, script, instance, rootUrl) {
+  const ctor = instance.constructor;
+  if (!ctor) {
+    return;
+  }
+  ctor._NodesFromScene?.forEach((params) => {
+    instance[params.propertyKey.toString()] = scene.getNodeByName(params.nodeName);
+  });
+  ctor._NodesFromDescendants?.forEach((params) => {
+    const descendant = object.getDescendants?.(params.directDescendantsOnly, (node) => node.name === params.nodeName)[0];
+    instance[params.propertyKey.toString()] = descendant ?? null;
+  });
+  ctor._AnimationGroups?.forEach((params) => {
+    instance[params.propertyKey.toString()] = scene.getAnimationGroupByName(params.animationGroupName);
+  });
+  ctor._SoundsFromScene?.forEach((params) => {
+    const sound = scene.getSoundByName?.(params.soundName);
+    instance[params.propertyKey.toString()] = sound ?? null;
+  });
+  ctor._GuiFromAsset?.forEach(async (params) => {
+    const guiUrl = `${rootUrl}assets/${params.pathInAssets}`;
+    try {
+      const response = await fetch(guiUrl);
+      const data = await response.json();
+      const gui = import_babylonjs_gui.AdvancedDynamicTexture.CreateFullscreenUI(data.name, true, scene);
+      gui.parseSerializedObject(data.content, false);
+      instance[params.propertyKey.toString()] = gui;
+      params.onGuiCreated?.(instance, gui);
+    } catch (e) {
+      console.error(`Failed to load GUI from asset: ${guiUrl}`);
+      throw e;
+    }
+  });
+  ctor._ParticleSystemsFromScene?.forEach((params) => {
+    const particleSystem = scene.particleSystems?.find((particleSystem2) => {
+      return particleSystem2.name === params.particleSystemName;
+    });
+    instance[params.propertyKey.toString()] = particleSystem;
+  });
+  ctor._VisibleInInspector?.forEach((params) => {
+    const propertyKey = params.propertyKey.toString();
+    const attachedScripts = script.values;
+    if (attachedScripts.hasOwnProperty(propertyKey) && attachedScripts[propertyKey].hasOwnProperty("value")) {
+      const value = attachedScripts[propertyKey].value;
+      switch (params.configuration.type) {
+        case "number":
+        case "boolean":
+          instance[propertyKey] = value;
+          break;
+        case "vector2":
+          instance[propertyKey] = import_babylonjs6.Vector2.FromArray(value);
+          break;
+        case "vector3":
+          instance[propertyKey] = import_babylonjs6.Vector3.FromArray(value);
+          break;
+      }
+    }
+  });
+}
+__name(applyDecorators, "applyDecorators");
+
+// src/loading/script.ts
+function applyScriptForObject(scene, object, scriptsMap, rootUrl) {
+  if (!object.metadata) {
+    return;
+  }
+  object.metadata.scripts?.forEach((script) => {
+    if (!script.enabled) {
+      return;
+    }
+    const exports2 = scriptsMap[script.key];
+    if (!exports2) {
+      return;
+    }
+    if (exports2.default) {
+      const instance = new exports2.default(object);
+      applyDecorators(scene, object, script, instance, rootUrl);
+      if (instance.onStart) {
+        scene.onBeforeRenderObservable.addOnce(() => instance.onStart());
+      }
+      if (instance.onUpdate) {
+        scene.onBeforeRenderObservable.add(() => instance.onUpdate());
+      }
+    } else {
+      if (exports2.onStart) {
+        scene.onBeforeRenderObservable.addOnce(() => exports2.onStart(object));
+      }
+      if (exports2.onUpdate) {
+        scene.onBeforeRenderObservable.add(() => exports2.onUpdate(object));
+      }
+    }
+  });
+  object.metadata.scripts = void 0;
+}
+__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;
+  if (!data) {
+    return;
+  }
+  const aggregate = new import_babylonjs10.PhysicsAggregate(mesh, data.shape.type, {
+    mass: data.massProperties.mass,
+    mesh: isMesh(mesh) ? mesh : void 0
+  });
+  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
+  });
+  aggregate.shape.density = data.shape.density;
+  aggregate.body.setMotionType(data.body.motionType);
+  aggregate.shape.material = data.material;
+  mesh.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 vlsPostProcess = null;
+var vlsPostProcessCameraConfigurations = /* @__PURE__ */ new Map();
+function getVLSPostProcess() {
+  return vlsPostProcess;
+}
+__name(getVLSPostProcess, "getVLSPostProcess");
+function disposeVLSPostProcess(scene) {
+  if (vlsPostProcess && scene.activeCamera) {
+    vlsPostProcess.dispose(scene.activeCamera);
+    vlsPostProcess = null;
+  }
+}
+__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);
+  return vlsPostProcess;
+}
+__name(createVLSPostProcess, "createVLSPostProcess");
+function serializeVLSPostProcess() {
+  if (!vlsPostProcess) {
+    return null;
+  }
+  return {
+    meshId: vlsPostProcess.mesh?.id,
+    exposure: vlsPostProcess.exposure,
+    decay: vlsPostProcess.decay,
+    weight: vlsPostProcess.weight,
+    density: vlsPostProcess.density,
+    invert: vlsPostProcess.invert,
+    useCustomMeshPosition: vlsPostProcess.useCustomMeshPosition,
+    customMeshPosition: vlsPostProcess.customMeshPosition.asArray()
+  };
+}
+__name(serializeVLSPostProcess, "serializeVLSPostProcess");
+function parseVLSPostProcess(scene, data) {
+  let mesh = null;
+  if (data.meshId) {
+    const result = scene.getMeshById(data.meshId);
+    if (result && isMesh(result)) {
+      mesh = result;
+    }
+  }
+  const vlsPostProcess2 = createVLSPostProcess(scene, mesh);
+  vlsPostProcess2.exposure = data.exposure;
+  vlsPostProcess2.decay = data.decay;
+  vlsPostProcess2.weight = data.weight;
+  vlsPostProcess2.density = data.density;
+  vlsPostProcess2.invert = data.invert;
+  vlsPostProcess2.useCustomMeshPosition = data.useCustomMeshPosition;
+  vlsPostProcess2.customMeshPosition.copyFrom(import_babylonjs14.Vector3.FromArray(data.customMeshPosition));
+  return vlsPostProcess2;
+}
+__name(parseVLSPostProcess, "parseVLSPostProcess");
+
+// src/rendering/ssr.ts
+var import_babylonjs19 = require("babylonjs");
+var ssrRenderingPipeline = null;
+var ssrRenderingPipelineCameraConfigurations = /* @__PURE__ */ new Map();
+function getSSRRenderingPipeline() {
+  return ssrRenderingPipeline;
+}
+__name(getSSRRenderingPipeline, "getSSRRenderingPipeline");
+function disposeSSRRenderingPipeline() {
+  if (ssrRenderingPipeline) {
+    ssrRenderingPipeline.dispose();
+    ssrRenderingPipeline = null;
+  }
+}
+__name(disposeSSRRenderingPipeline, "disposeSSRRenderingPipeline");
+function createSSRRenderingPipeline(scene, camera) {
+  ssrRenderingPipeline = new import_babylonjs19.SSRRenderingPipeline("SSRRenderingPipeline", scene, [camera]);
+  ssrRenderingPipeline.samples = 4;
+  return ssrRenderingPipeline;
+}
+__name(createSSRRenderingPipeline, "createSSRRenderingPipeline");
+function serializeSSRRenderingPipeline() {
+  if (!ssrRenderingPipeline) {
+    return null;
+  }
+  return {
+    samples: ssrRenderingPipeline.samples,
+    step: ssrRenderingPipeline.step,
+    thickness: ssrRenderingPipeline.thickness,
+    strength: ssrRenderingPipeline.strength,
+    reflectionSpecularFalloffExponent: ssrRenderingPipeline.reflectionSpecularFalloffExponent,
+    maxSteps: ssrRenderingPipeline.maxSteps,
+    maxDistance: ssrRenderingPipeline.maxDistance,
+    roughnessFactor: ssrRenderingPipeline.roughnessFactor,
+    reflectivityThreshold: ssrRenderingPipeline.reflectivityThreshold,
+    blurDispersionStrehgth: ssrRenderingPipeline.blurDispersionStrength,
+    clipToFrustum: ssrRenderingPipeline.clipToFrustum,
+    enableSmoothReflections: ssrRenderingPipeline.enableSmoothReflections,
+    enableAutomaticThicknessComputation: ssrRenderingPipeline.enableAutomaticThicknessComputation,
+    attenuateFacingCamera: ssrRenderingPipeline.attenuateFacingCamera,
+    attenuateScreenBorders: ssrRenderingPipeline.attenuateScreenBorders,
+    attenuateIntersectionDistance: ssrRenderingPipeline.attenuateIntersectionDistance,
+    attenuateBackfaceReflection: ssrRenderingPipeline.attenuateBackfaceReflection,
+    blurDownsample: ssrRenderingPipeline.blurDownsample,
+    selfCollisionNumSkip: ssrRenderingPipeline.selfCollisionNumSkip,
+    ssrDownsample: ssrRenderingPipeline.ssrDownsample,
+    backfaceDepthTextureDownsample: ssrRenderingPipeline.backfaceDepthTextureDownsample
+  };
+}
+__name(serializeSSRRenderingPipeline, "serializeSSRRenderingPipeline");
+function parseSSRRenderingPipeline(scene, camera, data) {
+  if (ssrRenderingPipeline) {
+    return ssrRenderingPipeline;
+  }
+  const pipeline = createSSRRenderingPipeline(scene, camera);
+  pipeline.samples = data.samples;
+  pipeline.step = data.step;
+  pipeline.thickness = data.thickness;
+  pipeline.strength = data.strength;
+  pipeline.reflectionSpecularFalloffExponent = data.reflectionSpecularFalloffExponent;
+  pipeline.maxSteps = data.maxSteps;
+  pipeline.maxDistance = data.maxDistance;
+  pipeline.roughnessFactor = data.roughnessFactor;
+  pipeline.reflectivityThreshold = data.reflectivityThreshold;
+  pipeline.blurDispersionStrength = data.blurDispersionStrehgth;
+  pipeline.clipToFrustum = data.clipToFrustum;
+  pipeline.enableSmoothReflections = data.enableSmoothReflections;
+  pipeline.enableAutomaticThicknessComputation = data.enableAutomaticThicknessComputation;
+  pipeline.attenuateFacingCamera = data.attenuateFacingCamera;
+  pipeline.attenuateScreenBorders = data.attenuateScreenBorders;
+  pipeline.attenuateIntersectionDistance = data.attenuateIntersectionDistance;
+  pipeline.attenuateBackfaceReflection = data.attenuateBackfaceReflection;
+  pipeline.blurDownsample = data.blurDownsample;
+  pipeline.selfCollisionNumSkip = data.selfCollisionNumSkip;
+  pipeline.ssrDownsample = data.ssrDownsample;
+  pipeline.backfaceDepthTextureDownsample = data.backfaceDepthTextureDownsample;
+  return pipeline;
+}
+__name(parseSSRRenderingPipeline, "parseSSRRenderingPipeline");
+
+// src/rendering/ssao.ts
+var import_babylonjs22 = require("babylonjs");
+var ssaoRenderingPipeline = null;
+var ssaoRenderingPipelineCameraConfigurations = /* @__PURE__ */ new Map();
+function getSSAO2RenderingPipeline() {
+  return ssaoRenderingPipeline;
+}
+__name(getSSAO2RenderingPipeline, "getSSAO2RenderingPipeline");
+function disposeSSAO2RenderingPipeline() {
+  if (ssaoRenderingPipeline) {
+    ssaoRenderingPipeline.dispose();
+    ssaoRenderingPipeline = null;
+  }
+}
+__name(disposeSSAO2RenderingPipeline, "disposeSSAO2RenderingPipeline");
+function createSSAO2RenderingPipeline(scene, camera) {
+  ssaoRenderingPipeline = new import_babylonjs22.SSAO2RenderingPipeline("SSAO2RenderingPipeline", scene, 1, [camera]);
+  ssaoRenderingPipeline.samples = 4;
+  return ssaoRenderingPipeline;
+}
+__name(createSSAO2RenderingPipeline, "createSSAO2RenderingPipeline");
+function serializeSSAO2RenderingPipeline() {
+  if (!ssaoRenderingPipeline) {
+    return null;
+  }
+  return {
+    radius: ssaoRenderingPipeline.radius,
+    totalStrength: ssaoRenderingPipeline.totalStrength,
+    samples: ssaoRenderingPipeline.samples,
+    maxZ: ssaoRenderingPipeline.maxZ,
+    minZAspect: ssaoRenderingPipeline.minZAspect,
+    epsilon: ssaoRenderingPipeline.epsilon,
+    textureSamples: ssaoRenderingPipeline.textureSamples,
+    bypassBlur: ssaoRenderingPipeline.bypassBlur,
+    bilateralSamples: ssaoRenderingPipeline.bilateralSamples,
+    bilateralSoften: ssaoRenderingPipeline.bilateralSoften,
+    bilateralTolerance: ssaoRenderingPipeline.bilateralTolerance,
+    expensiveBlur: ssaoRenderingPipeline.expensiveBlur
+  };
+}
+__name(serializeSSAO2RenderingPipeline, "serializeSSAO2RenderingPipeline");
+function parseSSAO2RenderingPipeline(scene, camera, data) {
+  if (ssaoRenderingPipeline) {
+    return ssaoRenderingPipeline;
+  }
+  const pipeline = createSSAO2RenderingPipeline(scene, camera);
+  pipeline.radius = data.radius;
+  pipeline.totalStrength = data.totalStrength;
+  pipeline.samples = data.samples;
+  pipeline.maxZ = data.maxZ;
+  pipeline.minZAspect = data.minZAspect;
+  pipeline.epsilon = data.epsilon;
+  pipeline.textureSamples = data.textureSamples;
+  pipeline.bypassBlur = data.bypassBlur;
+  pipeline.bilateralSamples = data.bilateralSamples;
+  pipeline.bilateralSoften = data.bilateralSoften;
+  pipeline.bilateralTolerance = data.bilateralTolerance;
+  pipeline.expensiveBlur = data.expensiveBlur;
+  return pipeline;
+}
+__name(parseSSAO2RenderingPipeline, "parseSSAO2RenderingPipeline");
+
+// src/rendering/motion-blur.ts
+var import_babylonjs25 = require("babylonjs");
+var motionBlurPostProcess = null;
+var motionBlurPostProcessCameraConfigurations = /* @__PURE__ */ new Map();
+function getMotionBlurPostProcess() {
+  return motionBlurPostProcess;
+}
+__name(getMotionBlurPostProcess, "getMotionBlurPostProcess");
+function disposeMotionBlurPostProcess() {
+  if (motionBlurPostProcess) {
+    motionBlurPostProcess.dispose();
+    motionBlurPostProcess = null;
+  }
+}
+__name(disposeMotionBlurPostProcess, "disposeMotionBlurPostProcess");
+function createMotionBlurPostProcess(scene, camera) {
+  motionBlurPostProcess = new import_babylonjs25.MotionBlurPostProcess("MotionBlurPostProcess", scene, 1, camera);
+  motionBlurPostProcess.motionStrength = 1;
+  motionBlurPostProcess.isObjectBased = true;
+  return motionBlurPostProcess;
+}
+__name(createMotionBlurPostProcess, "createMotionBlurPostProcess");
+function serializeMotionBlurPostProcess() {
+  if (!motionBlurPostProcess) {
+    return null;
+  }
+  return {
+    isObjectBased: motionBlurPostProcess.isObjectBased,
+    motionStrength: motionBlurPostProcess.motionStrength,
+    motionBlurSamples: motionBlurPostProcess.motionBlurSamples
+  };
+}
+__name(serializeMotionBlurPostProcess, "serializeMotionBlurPostProcess");
+function parseMotionBlurPostProcess(scene, camera, data) {
+  if (motionBlurPostProcess) {
+    return motionBlurPostProcess;
+  }
+  const postProcess = createMotionBlurPostProcess(scene, camera);
+  postProcess.isObjectBased = data.isObjectBased;
+  postProcess.motionStrength = data.motionStrength;
+  postProcess.motionBlurSamples = data.motionBlurSamples;
+  return postProcess;
+}
+__name(parseMotionBlurPostProcess, "parseMotionBlurPostProcess");
+
+// src/rendering/default-pipeline.ts
+var import_babylonjs28 = require("babylonjs");
+var import_babylonjs29 = require("babylonjs");
+var import_babylonjs30 = require("babylonjs");
+var defaultRenderingPipeline = null;
+var defaultPipelineCameraConfigurations = /* @__PURE__ */ new Map();
+function getDefaultRenderingPipeline() {
+  return defaultRenderingPipeline;
+}
+__name(getDefaultRenderingPipeline, "getDefaultRenderingPipeline");
+function disposeDefaultRenderingPipeline() {
+  if (defaultRenderingPipeline) {
+    defaultRenderingPipeline.dispose();
+    defaultRenderingPipeline = null;
+  }
+}
+__name(disposeDefaultRenderingPipeline, "disposeDefaultRenderingPipeline");
+function createDefaultRenderingPipeline(scene, camera) {
+  defaultRenderingPipeline = new import_babylonjs30.DefaultRenderingPipeline("DefaultRenderingPipeline", true, scene, [camera]);
+  defaultRenderingPipeline.samples = 4;
+  defaultRenderingPipeline.depthOfField.lensSize = 512;
+  defaultRenderingPipeline.depthOfField.fStop = 0.25;
+  defaultRenderingPipeline.depthOfField.focusDistance = 55e3;
+  return defaultRenderingPipeline;
+}
+__name(createDefaultRenderingPipeline, "createDefaultRenderingPipeline");
+function serializeDefaultRenderingPipeline() {
+  if (!defaultRenderingPipeline) {
+    return null;
+  }
+  return {
+    samples: defaultRenderingPipeline.samples,
+    fxaaEnabled: defaultRenderingPipeline.fxaaEnabled,
+    imageProcessingEnabled: defaultRenderingPipeline.imageProcessingEnabled,
+    exposure: defaultRenderingPipeline.imageProcessing?.exposure,
+    contrast: defaultRenderingPipeline.imageProcessing?.contrast,
+    fromLinearSpace: defaultRenderingPipeline.imageProcessing?.fromLinearSpace,
+    toneMappingEnabled: defaultRenderingPipeline.imageProcessing?.toneMappingEnabled,
+    toneMappingType: defaultRenderingPipeline.imageProcessing?.toneMappingType,
+    ditheringEnabled: defaultRenderingPipeline.imageProcessing?.ditheringEnabled,
+    ditheringIntensity: defaultRenderingPipeline.imageProcessing?.ditheringIntensity,
+    bloomEnabled: defaultRenderingPipeline.bloomEnabled,
+    bloomThreshold: defaultRenderingPipeline.bloomThreshold,
+    bloomWeight: defaultRenderingPipeline.bloomWeight,
+    bloomScale: defaultRenderingPipeline.bloomScale,
+    bloomKernel: defaultRenderingPipeline.bloomKernel,
+    sharpenEnabled: defaultRenderingPipeline.sharpenEnabled,
+    sharpenEdgeAmount: defaultRenderingPipeline.sharpen.edgeAmount,
+    sharpenColorAmount: defaultRenderingPipeline.sharpen.colorAmount,
+    grainEnabled: defaultRenderingPipeline.grainEnabled,
+    grainIntensity: defaultRenderingPipeline.grain.intensity,
+    grainAnimated: defaultRenderingPipeline.grain.animated,
+    depthOfFieldEnabled: defaultRenderingPipeline.depthOfFieldEnabled,
+    depthOfFieldBlurLevel: defaultRenderingPipeline.depthOfFieldBlurLevel,
+    lensSize: defaultRenderingPipeline.depthOfField.lensSize,
+    fStop: defaultRenderingPipeline.depthOfField.fStop,
+    focusDistance: defaultRenderingPipeline.depthOfField.focusDistance,
+    focalLength: defaultRenderingPipeline.depthOfField.focalLength,
+    // Since v5.0.0-alpha.9
+    vignetteEnabled: defaultRenderingPipeline.imageProcessing?.vignetteEnabled,
+    vignetteColor: defaultRenderingPipeline.imageProcessing?.vignetteColor.asArray(),
+    vignetteWeight: defaultRenderingPipeline.imageProcessing?.vignetteWeight,
+    chromaticAberrationEnabled: defaultRenderingPipeline.chromaticAberrationEnabled,
+    aberrationAmount: defaultRenderingPipeline.chromaticAberration.aberrationAmount,
+    radialIntensity: defaultRenderingPipeline.chromaticAberration.radialIntensity,
+    direction: defaultRenderingPipeline.chromaticAberration.direction.asArray(),
+    centerPosition: defaultRenderingPipeline.chromaticAberration.centerPosition.asArray(),
+    glowLayerEnabled: defaultRenderingPipeline.glowLayerEnabled,
+    glowLayerIntensity: defaultRenderingPipeline.glowLayer?.intensity,
+    glowLayerBlurKernelSize: defaultRenderingPipeline.glowLayer?.blurKernelSize
+  };
+}
+__name(serializeDefaultRenderingPipeline, "serializeDefaultRenderingPipeline");
+function parseDefaultRenderingPipeline(scene, camera, data) {
+  if (defaultRenderingPipeline) {
+    return defaultRenderingPipeline;
+  }
+  const pipeline = createDefaultRenderingPipeline(scene, camera);
+  pipeline.samples = data.samples;
+  pipeline.fxaaEnabled = data.fxaaEnabled;
+  pipeline.imageProcessingEnabled = data.imageProcessingEnabled;
+  if (pipeline.imageProcessing) {
+    pipeline.imageProcessing.exposure = data.exposure;
+    pipeline.imageProcessing.contrast = data.contrast;
+    pipeline.imageProcessing.fromLinearSpace = data.fromLinearSpace;
+    pipeline.imageProcessing.toneMappingEnabled = data.toneMappingEnabled;
+    pipeline.imageProcessing.toneMappingType = data.toneMappingType;
+    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.vignetteWeight = data.vignetteWeight ?? 0.3;
+  }
+  pipeline.bloomEnabled = data.bloomEnabled;
+  pipeline.bloomThreshold = data.bloomThreshold;
+  pipeline.bloomWeight = data.bloomWeight;
+  pipeline.bloomScale = data.bloomScale;
+  pipeline.bloomKernel = data.bloomKernel;
+  pipeline.sharpenEnabled = data.sharpenEnabled;
+  pipeline.sharpen.edgeAmount = data.sharpenEdgeAmount;
+  pipeline.sharpen.colorAmount = data.sharpenColorAmount;
+  pipeline.grainEnabled = data.grainEnabled;
+  pipeline.grain.intensity = data.grainIntensity;
+  pipeline.grain.animated = data.grainAnimated;
+  pipeline.depthOfFieldEnabled = data.depthOfFieldEnabled;
+  pipeline.depthOfFieldBlurLevel = data.depthOfFieldBlurLevel;
+  pipeline.depthOfField.lensSize = data.lensSize;
+  pipeline.depthOfField.fStop = data.fStop;
+  pipeline.depthOfField.focusDistance = data.focusDistance;
+  pipeline.depthOfField.focalLength = data.focalLength;
+  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.glowLayerEnabled = data.glowLayerEnabled ?? false;
+  if (pipeline.glowLayer) {
+    pipeline.glowLayer.intensity = data.glowLayerIntensity ?? 1;
+    pipeline.glowLayer.blurKernelSize = data.glowLayerBlurKernelSize ?? 32;
+  }
+  return pipeline;
+}
+__name(parseDefaultRenderingPipeline, "parseDefaultRenderingPipeline");
+
+// src/loading/rendering.ts
+function applyRenderingConfigurations(scene, rendering) {
+  const postProcessConfigurations = Array.isArray(rendering) ? rendering : [];
+  postProcessConfigurations.forEach((configuration) => {
+    const camera = scene.getCameraById(configuration.cameraId);
+    if (!camera) {
+      return;
+    }
+    if (configuration.ssao2RenderingPipeline) {
+      ssaoRenderingPipelineCameraConfigurations.set(camera, configuration.ssao2RenderingPipeline);
+    }
+    if (configuration.vlsPostProcess) {
+      vlsPostProcessCameraConfigurations.set(camera, configuration.vlsPostProcess);
+    }
+    if (configuration.ssrRenderingPipeline) {
+      ssrRenderingPipelineCameraConfigurations.set(camera, configuration.ssrRenderingPipeline);
+    }
+    if (configuration.motionBlurPostProcess) {
+      motionBlurPostProcessCameraConfigurations.set(camera, configuration.motionBlurPostProcess);
+    }
+    if (configuration.defaultRenderingPipeline) {
+      defaultPipelineCameraConfigurations.set(camera, configuration.defaultRenderingPipeline);
+    }
+  });
+}
+__name(applyRenderingConfigurations, "applyRenderingConfigurations");
+
+// src/rendering/tools.ts
+function saveRenderingConfigurationForCamera(camera) {
+  ssaoRenderingPipelineCameraConfigurations.set(camera, serializeSSAO2RenderingPipeline());
+  vlsPostProcessCameraConfigurations.set(camera, serializeVLSPostProcess());
+  ssrRenderingPipelineCameraConfigurations.set(camera, serializeSSRRenderingPipeline());
+  motionBlurPostProcessCameraConfigurations.set(camera, serializeMotionBlurPostProcess());
+  defaultPipelineCameraConfigurations.set(camera, serializeDefaultRenderingPipeline());
+}
+__name(saveRenderingConfigurationForCamera, "saveRenderingConfigurationForCamera");
+function applyRenderingConfigurationForCamera(camera) {
+  disposeSSAO2RenderingPipeline();
+  disposeVLSPostProcess(camera.getScene());
+  disposeSSRRenderingPipeline();
+  disposeMotionBlurPostProcess();
+  disposeDefaultRenderingPipeline();
+  const ssao2RenderingPipeline = ssaoRenderingPipelineCameraConfigurations.get(camera);
+  if (ssao2RenderingPipeline) {
+    parseSSAO2RenderingPipeline(camera.getScene(), camera, ssao2RenderingPipeline);
+  }
+  const vlsPostProcess2 = vlsPostProcessCameraConfigurations.get(camera);
+  if (vlsPostProcess2) {
+    parseVLSPostProcess(camera.getScene(), vlsPostProcess2);
+  }
+  const ssrRenderingPipeline2 = ssrRenderingPipelineCameraConfigurations.get(camera);
+  if (ssrRenderingPipeline2) {
+    parseSSRRenderingPipeline(camera.getScene(), camera, ssrRenderingPipeline2);
+  }
+  const motionBlurPostProcess2 = motionBlurPostProcessCameraConfigurations.get(camera);
+  if (motionBlurPostProcess2) {
+    parseMotionBlurPostProcess(camera.getScene(), camera, motionBlurPostProcess2);
+  }
+  const defaultRenderingPipeline2 = defaultPipelineCameraConfigurations.get(camera);
+  if (defaultRenderingPipeline2) {
+    parseDefaultRenderingPipeline(camera.getScene(), camera, defaultRenderingPipeline2);
+  }
+}
+__name(applyRenderingConfigurationForCamera, "applyRenderingConfigurationForCamera");
+
+// src/tools/light.ts
+var import_babylonjs34 = require("babylonjs");
+var import_babylonjs35 = require("babylonjs");
+function configureShadowMapRenderListPredicate(scene) {
+  scene.lights.forEach((light) => {
+    const shadowMap = light.getShadowGenerator()?.getShadowMap();
+    if (!shadowMap) {
+      return;
+    }
+    shadowMap.renderListPredicate = (mesh) => {
+      const distance = import_babylonjs34.Vector3.Distance(mesh.getAbsolutePosition(), light.getAbsolutePosition());
+      return distance <= light.range;
+    };
+  });
+}
+__name(configureShadowMapRenderListPredicate, "configureShadowMapRenderListPredicate");
+async function configureShadowMapRefreshRate(scene) {
+  scene.executeWhenReady(() => {
+    scene.lights.forEach((light) => {
+      const shadowMap = light.getShadowGenerator()?.getShadowMap();
+      if (shadowMap) {
+        shadowMap.refreshRate = light.metadata?.refreshRate ?? import_babylonjs35.RenderTargetTexture.REFRESHRATE_RENDER_ONEVERYFRAME;
+      }
+    });
+  });
+}
+__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) => {
+  audioParser?.(parsedData, scene, container, rootUrl);
+  parsedData.sounds?.forEach((sound) => {
+    const instance = container.sounds?.find((s) => s.name === sound.name);
+    if (instance) {
+      instance.id = sound.id;
+      instance.uniqueId = sound.uniqueId;
+    }
+  });
+});
+
+// src/tools/scalar.ts
+function getPowerOfTwoUntil(limit) {
+  let size = 1;
+  while (size <= limit) {
+    size <<= 1;
+  }
+  return size >> 1;
+}
+__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) => {
+  if (scene.loadingQuality === "high" || !sourceProperty.metadata?.baseSize) {
+    return textureParser(sourceProperty, scene, rootUrl);
+  }
+  const width = sourceProperty.metadata.baseSize.width;
+  const height = sourceProperty.metadata.baseSize.height;
+  const isPowerOfTwo = width === getPowerOfTwoUntil(width) || height === getPowerOfTwoUntil(height);
+  let suffix = "";
+  switch (scene.loadingQuality) {
+    case "medium":
+      let midWidth = width * 0.66 >> 0;
+      let midHeight = height * 0.66 >> 0;
+      if (isPowerOfTwo) {
+        midWidth = getPowerOfTwoUntil(midWidth);
+        midHeight = getPowerOfTwoUntil(midHeight);
+      }
+      suffix = `_${midWidth}_${midHeight}`;
+      break;
+    case "low":
+      let lowWidth = width * 0.33 >> 0;
+      let lowHeight = height * 0.33 >> 0;
+      if (isPowerOfTwo) {
+        lowWidth = getPowerOfTwoUntil(lowWidth);
+        lowHeight = getPowerOfTwoUntil(lowHeight);
+      }
+      suffix = `_${lowWidth}_${lowHeight}`;
+      break;
+  }
+  const name = sourceProperty.name;
+  if (!name || !suffix) {
+    return textureParser(sourceProperty, scene, rootUrl);
+  }
+  const finalUrl = name.split("/");
+  const filename = finalUrl.pop();
+  if (!filename) {
+    return textureParser(sourceProperty, scene, rootUrl);
+  }
+  const extension = filename.split(".").pop();
+  const baseFilename = filename.replace(`.${extension}`, "");
+  const newFilename = `${baseFilename}${suffix}.${extension}`;
+  finalUrl.push(newFilename);
+  sourceProperty.name = finalUrl.join("/");
+  return textureParser(sourceProperty, scene, rootUrl);
+};
+
+// src/loading/loader.ts
+var import_babylonjs45 = require("babylonjs");
+var import_babylonjs46 = require("babylonjs");
+async function loadScene(rootUrl, sceneFilename, scene, scriptsMap, options) {
+  scene.loadingQuality = options?.quality ?? "high";
+  await (0, import_babylonjs45.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) {
+    scene.meshes.forEach((m) => isMesh(m) && m._checkDelayState());
+  }
+  const waitingItemsCount = scene.getWaitingItemsCount();
+  while (!scene.isReady() || scene.getWaitingItemsCount() > 0) {
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    const loadedItemsCount = waitingItemsCount - scene.getWaitingItemsCount();
+    options?.onProgress?.(
+      0.5 + loadedItemsCount / waitingItemsCount * 0.5
+    );
+  }
+  options?.onProgress?.(1);
+  configureShadowMapRenderListPredicate(scene);
+  configureShadowMapRefreshRate(scene);
+  if (scene.metadata?.rendering) {
+    applyRenderingConfigurations(scene, scene.metadata.rendering);
+    if (scene.activeCamera) {
+      applyRenderingConfigurationForCamera(scene.activeCamera);
+    }
+  }
+  applyScriptForObject(scene, scene, scriptsMap, rootUrl);
+  scene.transformNodes.forEach((transformNode) => {
+    applyScriptForObject(scene, transformNode, scriptsMap, rootUrl);
+  });
+  scene.meshes.forEach((mesh) => {
+    configurePhysicsAggregate(mesh);
+    applyScriptForObject(scene, mesh, scriptsMap, rootUrl);
+  });
+  scene.lights.forEach((light) => {
+    applyScriptForObject(scene, light, scriptsMap, rootUrl);
+  });
+  scene.cameras.forEach((camera) => {
+    applyScriptForObject(scene, camera, scriptsMap, rootUrl);
+  });
+}
+__name(loadScene, "loadScene");
+
+// src/tools/texture.ts
+function configureEngineToUseCompressedTextures(engine) {
+  engine.setTextureFormatToUse([
+    "-dxt.ktx",
+    "-astc.ktx",
+    "-pvrtc.ktx",
+    "-etc1.ktx",
+    "-etc2.ktx"
+  ]);
+}
+__name(configureEngineToUseCompressedTextures, "configureEngineToUseCompressedTextures");
+
+// src/decorators/scene.ts
+function nodeFromScene(nodeName) {
+  return function(target, propertyKey) {
+    const ctor = target.constructor;
+    ctor._NodesFromScene ??= [];
+    ctor._NodesFromScene.push({ propertyKey, nodeName });
+  };
+}
+__name(nodeFromScene, "nodeFromScene");
+function nodeFromDescendants(nodeName, directDescendantsOnly = false) {
+  return function(target, propertyKey) {
+    const ctor = target.constructor;
+    ctor._NodesFromDescendants ??= [];
+    ctor._NodesFromDescendants.push({ propertyKey, nodeName, directDescendantsOnly });
+  };
+}
+__name(nodeFromDescendants, "nodeFromDescendants");
+function animationGroupFromScene(animationGroupName) {
+  return function(target, propertyKey) {
+    const ctor = target.constructor;
+    ctor._AnimationGroups ??= [];
+    ctor._AnimationGroups.push({ animationGroupName, propertyKey });
+  };
+}
+__name(animationGroupFromScene, "animationGroupFromScene");
+
+// src/decorators/gui.ts
+function guiFromAsset(pathInAssets, onGuiCreated) {
+  return function(target, propertyKey) {
+    const ctor = target.constructor;
+    ctor._GuiFromAsset ??= [];
+    ctor._GuiFromAsset.push({ propertyKey, pathInAssets, onGuiCreated });
+  };
+}
+__name(guiFromAsset, "guiFromAsset");
+
+// src/decorators/sound.ts
+function soundFromScene(soundName) {
+  return function(target, propertyKey) {
+    const ctor = target.constructor;
+    ctor._SoundsFromScene ??= [];
+    ctor._SoundsFromScene.push({ propertyKey, soundName });
+  };
+}
+__name(soundFromScene, "soundFromScene");
+
+// src/decorators/particle-systems.ts
+function particleSystemFromScene(particleSystemName) {
+  return function(target, propertyKey) {
+    const ctor = target.constructor;
+    ctor._ParticleSystemsFromScene ??= [];
+    ctor._ParticleSystemsFromScene.push({ propertyKey, particleSystemName });
+  };
+}
+__name(particleSystemFromScene, "particleSystemFromScene");
+
+// src/decorators/inspector.ts
+function visibleAsBoolean(label) {
+  return function(target, propertyKey) {
+    const ctor = target.constructor;
+    ctor._VisibleInInspector ??= [];
+    ctor._VisibleInInspector.push({
+      label,
+      propertyKey,
+      configuration: {
+        type: "boolean"
+      }
+    });
+  };
+}
+__name(visibleAsBoolean, "visibleAsBoolean");
+function visibleAsNumber(label, configuration) {
+  return function(target, propertyKey) {
+    const ctor = target.constructor;
+    ctor._VisibleInInspector ??= [];
+    ctor._VisibleInInspector.push({
+      label,
+      propertyKey,
+      configuration: {
+        ...configuration,
+        type: "number"
+      }
+    });
+  };
+}
+__name(visibleAsNumber, "visibleAsNumber");
+function visibleAsVector2(label, configuration) {
+  return function(target, propertyKey) {
+    const ctor = target.constructor;
+    ctor._VisibleInInspector ??= [];
+    ctor._VisibleInInspector.push({
+      label,
+      propertyKey,
+      configuration: {
+        ...configuration,
+        type: "vector2"
+      }
+    });
+  };
+}
+__name(visibleAsVector2, "visibleAsVector2");
+function visibleAsVector3(label, configuration) {
+  return function(target, propertyKey) {
+    const ctor = target.constructor;
+    ctor._VisibleInInspector ??= [];
+    ctor._VisibleInInspector.push({
+      label,
+      propertyKey,
+      configuration: {
+        ...configuration,
+        type: "vector3"
+      }
+    });
+  };
+}
+__name(visibleAsVector3, "visibleAsVector3");
+function visibleAsColor3(label, configuration) {
+  return function(target, propertyKey) {
+    const ctor = target.constructor;
+    ctor._VisibleInInspector ??= [];
+    ctor._VisibleInInspector.push({
+      label,
+      propertyKey,
+      configuration: {
+        ...configuration,
+        type: "color3"
+      }
+    });
+  };
+}
+__name(visibleAsColor3, "visibleAsColor3");
+function visibleAsColor4(label, configuration) {
+  return function(target, propertyKey) {
+    const ctor = target.constructor;
+    ctor._VisibleInInspector ??= [];
+    ctor._VisibleInInspector.push({
+      label,
+      propertyKey,
+      configuration: {
+        ...configuration,
+        type: "color4"
+      }
+    });
+  };
+}
+__name(visibleAsColor4, "visibleAsColor4");
+
+// src/tools/sound.ts
+function getSoundById(id, scene) {
+  const soundTracks = scene.soundTracks ?? [];
+  if (!soundTracks.length) {
+    soundTracks.push(scene.mainSoundTrack);
+  }
+  for (let i = 0, len = soundTracks.length; i < len; i++) {
+    const sound = soundTracks[i].soundCollection.find((s) => s.id === id);
+    if (sound) {
+      return sound;
+    }
+  }
+  return null;
+}
+__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");
+function cloneKey(dataType, key) {
+  let value;
+  switch (dataType) {
+    case import_babylonjs50.Animation.ANIMATIONTYPE_FLOAT:
+      value = key.value;
+      break;
+    default:
+      value = key.value.clone();
+      break;
+  }
+  return {
+    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()
+  };
+}
+__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 null;
+}
+__name(getAnimationTypeForObject, "getAnimationTypeForObject");
+function getPropertyValue(object, property) {
+  const parts = property.split(".");
+  let value = object;
+  for (let i = 0; i < parts.length; ++i) {
+    value = value[parts[i]];
+  }
+  return value;
+}
+__name(getPropertyValue, "getPropertyValue");
+
+// src/cinematic/parse.ts
+var import_babylonjs56 = require("babylonjs");
+var import_babylonjs57 = require("babylonjs");
+var import_babylonjs58 = require("babylonjs");
+function parseCinematic(data, scene) {
+  return {
+    name: data.name,
+    framesPerSecond: data.framesPerSecond,
+    outputFramesPerSecond: data.outputFramesPerSecond,
+    tracks: data.tracks.map((track) => {
+      let node = null;
+      let animationType = null;
+      if (track.node) {
+        node = scene.getNodeById(track.node);
+      } else if (track.defaultRenderingPipeline) {
+        node = getDefaultRenderingPipeline();
+      }
+      if (track.propertyPath) {
+        const value = getPropertyValue(node, track.propertyPath);
+        animationType = getAnimationTypeForObject(value);
+      }
+      let sound = null;
+      if (track.sound) {
+        sound = getSoundById(track.sound, scene);
+      }
+      return {
+        node,
+        sound,
+        propertyPath: track.propertyPath,
+        defaultRenderingPipeline: track.defaultRenderingPipeline,
+        animationGroup: track.animationGroup ? scene.getAnimationGroupByName(track.animationGroup) : null,
+        animationGroups: track.animationGroups,
+        sounds: track.sounds,
+        keyFrameEvents: track.keyFrameEvents,
+        keyFrameAnimations: node && animationType !== null && track.keyFrameAnimations?.map((keyFrame) => {
+          const animationKey = keyFrame.type === "key" ? keyFrame : null;
+          if (animationKey) {
+            return {
+              ...animationKey,
+              value: parseCinematicKeyValue(animationKey.value, animationType),
+              inTangent: parseCinematicKeyValue(animationKey.inTangent, animationType),
+              outTangent: parseCinematicKeyValue(animationKey.outTangent, animationType)
+            };
+          }
+          const animationKeyCut = keyFrame.type === "cut" ? keyFrame : null;
+          if (animationKeyCut) {
+            return {
+              ...animationKeyCut,
+              key1: {
+                ...animationKeyCut.key1,
+                value: parseCinematicKeyValue(animationKeyCut.key1.value, animationType),
+                inTangent: parseCinematicKeyValue(animationKeyCut.key1.inTangent, animationType),
+                outTangent: parseCinematicKeyValue(animationKeyCut.key1.outTangent, animationType)
+              },
+              key2: {
+                ...animationKeyCut.key2,
+                value: parseCinematicKeyValue(animationKeyCut.key2.value, animationType),
+                inTangent: parseCinematicKeyValue(animationKeyCut.key2.inTangent, animationType),
+                outTangent: parseCinematicKeyValue(animationKeyCut.key2.outTangent, animationType)
+              }
+            };
+          }
+        })
+      };
+    })
+  };
+}
+__name(parseCinematic, "parseCinematic");
+function parseCinematicKeyValue(value, type) {
+  if (value === null) {
+    return null;
+  }
+  if (value === void 0) {
+    return void 0;
+  }
+  switch (type) {
+    case import_babylonjs56.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);
+  }
+}
+__name(parseCinematicKeyValue, "parseCinematicKeyValue");
+
+// src/cinematic/events/set-enabled.ts
+function handleSetEnabledEvent(scene, config) {
+  const node = scene.getNodeById(config.node);
+  node?.setEnabled(config.value);
+}
+__name(handleSetEnabledEvent, "handleSetEnabledEvent");
+
+// src/cinematic/events/apply-impulse.ts
+var import_babylonjs61 = require("babylonjs");
+function handleApplyImpulseEvent(scene, config) {
+  const meshes = config.mesh ? [scene.getNodeById(config.mesh)] : scene.meshes;
+  meshes.forEach((mesh) => {
+    if (mesh.physicsAggregate?.body) {
+      mesh.physicsAggregate.body.applyImpulse(
+        import_babylonjs61.Vector3.FromArray(config.force),
+        import_babylonjs61.Vector3.FromArray(config.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");
+function generateCinematicAnimationGroup(cinematic, scene) {
+  const result = new import_babylonjs70.AnimationGroup(cinematic.name, scene);
+  cinematic.tracks.forEach((track) => {
+    const animationGroup = track.animationGroup;
+    if (animationGroup) {
+      track.animationGroups?.forEach((configuration) => {
+        animationGroup.targetedAnimations.forEach((targetedAnimation) => {
+          let animation2 = null;
+          defer: {
+            const existingTargetedAnimations = result.targetedAnimations.filter((ta2) => ta2.target === targetedAnimation.target);
+            if (existingTargetedAnimations.length) {
+              const existingTargetedAnimationsPair = existingTargetedAnimations.find((et) => et.animation.targetProperty === targetedAnimation.animation.targetProperty);
+              if (existingTargetedAnimationsPair) {
+                animation2 = existingTargetedAnimationsPair.animation;
+                break defer;
+              }
+            }
+            animation2 = targetedAnimation.animation.clone();
+            animation2.setKeys([]);
+            animation2.name = import_babylonjs65.Tools.RandomId();
+            animation2.framePerSecond = cinematic.framesPerSecond;
+          }
+          const keys2 = animation2.getKeys();
+          const sourceKeys = targetedAnimation.animation.getKeys();
+          const speed = configuration.speed;
+          const normalizedFps = cinematic.framesPerSecond / targetedAnimation.animation.framePerSecond / speed;
+          sourceKeys.forEach((k) => {
+            if (k.frame >= configuration.startFrame && k.frame <= configuration.endFrame) {
+              keys2.push({
+                ...cloneKey(targetedAnimation.animation.dataType, k),
+                frame: configuration.frame + k.frame * normalizedFps
+              });
+            }
+          });
+          animation2.setKeys(keys2);
+          result.addTargetedAnimation(animation2, targetedAnimation.target);
+        });
+      });
+    }
+    const sound = track.sound;
+    const soundBuffer = sound?.getAudioBuffer();
+    if (sound && soundBuffer && track.sounds?.length) {
+      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);
+      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) => {
+          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, () => {
+          sound.stop();
+        }));
+      });
+      soundAnimation.setKeys([
+        { frame: 0, value: 0 },
+        { frame: maxFrame, value: maxFrame }
+      ]);
+      result.addTargetedAnimation(soundAnimation, dummyObject);
+    }
+    if (track.keyFrameEvents) {
+      const dummyObject = {
+        dummy: 0
+      };
+      const eventsAnimation = new import_babylonjs67.Animation("events", "dummy", 60, import_babylonjs67.Animation.ANIMATIONTYPE_FLOAT, import_babylonjs67.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, () => {
+          switch (configuration.data?.type) {
+            case "set-enabled":
+              handleSetEnabledEvent(scene, configuration.data);
+              break;
+            case "apply-impulse":
+              handleApplyImpulseEvent(scene, configuration.data);
+              break;
+          }
+        }));
+      });
+      eventsAnimation.setKeys([
+        { frame: 0, value: 0 },
+        { frame: maxFrame, value: maxFrame }
+      ]);
+      result.addTargetedAnimation(eventsAnimation, dummyObject);
+    }
+    const node = track.defaultRenderingPipeline ? getDefaultRenderingPipeline() : track.node;
+    if (!node || !track.propertyPath || !track.keyFrameAnimations) {
+      return;
+    }
+    const value = getPropertyValue(node, track.propertyPath);
+    const animationType = getAnimationTypeForObject(value);
+    if (animationType === null) {
+      return;
+    }
+    const animation = new import_babylonjs67.Animation(track.propertyPath, track.propertyPath, 60, animationType, import_babylonjs67.Animation.ANIMATIONLOOPMODE_CYCLE, false);
+    const keys = [];
+    track.keyFrameAnimations?.forEach((keyFrame) => {
+      const animationKey = keyFrame.type === "key" ? keyFrame : null;
+      if (animationKey) {
+        return keys.push(animationKey);
+      }
+      const animationKeyCut = keyFrame.type === "cut" ? keyFrame : null;
+      if (animationKeyCut) {
+        keys.push(animationKeyCut.key1);
+        keys.push(animationKeyCut.key2);
+      }
+    });
+    animation.setKeys(keys);
+    result.addTargetedAnimation(animation, node);
+  });
+  result.normalize();
+  return result;
+}
+__name(generateCinematicAnimationGroup, "generateCinematicAnimationGroup");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  animationGroupFromScene,
+  configureEngineToUseCompressedTextures,
+  createDefaultRenderingPipeline,
+  createMotionBlurPostProcess,
+  createSSAO2RenderingPipeline,
+  createSSRRenderingPipeline,
+  createVLSPostProcess,
+  defaultPipelineCameraConfigurations,
+  disposeDefaultRenderingPipeline,
+  disposeMotionBlurPostProcess,
+  disposeSSAO2RenderingPipeline,
+  disposeSSRRenderingPipeline,
+  disposeVLSPostProcess,
+  generateCinematicAnimationGroup,
+  getDefaultRenderingPipeline,
+  getMotionBlurPostProcess,
+  getSSAO2RenderingPipeline,
+  getSSRRenderingPipeline,
+  getVLSPostProcess,
+  guiFromAsset,
+  loadScene,
+  motionBlurPostProcessCameraConfigurations,
+  nodeFromDescendants,
+  nodeFromScene,
+  parseCinematic,
+  parseCinematicKeyValue,
+  parseDefaultRenderingPipeline,
+  parseMotionBlurPostProcess,
+  parseSSAO2RenderingPipeline,
+  parseSSRRenderingPipeline,
+  parseVLSPostProcess,
+  particleSystemFromScene,
+  serializeDefaultRenderingPipeline,
+  serializeMotionBlurPostProcess,
+  serializeSSAO2RenderingPipeline,
+  serializeSSRRenderingPipeline,
+  serializeVLSPostProcess,
+  soundFromScene,
+  ssaoRenderingPipelineCameraConfigurations,
+  ssrRenderingPipelineCameraConfigurations,
+  visibleAsBoolean,
+  visibleAsColor3,
+  visibleAsColor4,
+  visibleAsNumber,
+  visibleAsVector2,
+  visibleAsVector3,
+  vlsPostProcessCameraConfigurations
+});