babylonjs-editor-tools 0.0.8 → 0.0.10

package/build/src/index.js

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

package/build/src/loading/loader.js

@@ -0,0 +1,59 @@
+import { Vector3 } from "@babylonjs/core/Maths/math.vector";
+import { AppendSceneAsync } from "@babylonjs/core/Loading/sceneLoader";
+import { SceneLoaderFlags } from "@babylonjs/core/Loading/sceneLoaderFlags";
+import { isMesh } from "../tools/guards";
+import { applyScriptForObject } from "./script";
+import { configurePhysicsAggregate } from "./physics";
+import { applyRenderingConfigurations } from "./rendering";
+import { applyRenderingConfigurationForCamera } from "../rendering/tools";
+import { configureShadowMapRefreshRate, configureShadowMapRenderListPredicate } from "../tools/light";
+import "./sound";
+import "./texture";
+export async function loadScene(rootUrl, sceneFilename, scene, scriptsMap, options) {
+    scene.loadingQuality = options?.quality ?? "high";
+    await AppendSceneAsync(`${rootUrl}${sceneFilename}`, scene, {
+        pluginExtension: ".babylon",
+        onProgress: (event) => {
+            const progress = Math.min((event.loaded / event.total) * 0.5);
+            options?.onProgress?.(progress);
+        },
+    });
+    // Ensure all meshes perform their delay state check
+    if (SceneLoaderFlags.ForceFullSceneLoadingForIncremental) {
+        scene.meshes.forEach((m) => isMesh(m) && m._checkDelayState());
+    }
+    const waitingItemsCount = scene.getWaitingItemsCount();
+    // Wait until scene is ready.
+    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);
+        }
+    }
+    if (scene.metadata?.physicsGravity) {
+        scene.getPhysicsEngine()?.setGravity(Vector3.FromArray(scene.metadata?.physicsGravity));
+    }
+    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);
+    });
+}
+//# sourceMappingURL=loader.js.map

package/build/src/loading/physics.js

@@ -0,0 +1,36 @@
+import { Vector3, Quaternion } from "@babylonjs/core/Maths/math.vector";
+import { PhysicsAggregate } from "@babylonjs/core/Physics/v2/physicsAggregate";
+import { isInstancedMesh, isMesh } from "../tools/guards";
+/**
+ * Parses and loads the physics aggregate data for the given mesh.
+ * @param mesh defines the reference to the mesh object.
+ */
+export function configurePhysicsAggregate(transformNode) {
+    const data = transformNode.metadata?.physicsAggregate;
+    if (!data) {
+        return;
+    }
+    let mesh = undefined;
+    if (isMesh(transformNode)) {
+        mesh = transformNode;
+    }
+    else if (isInstancedMesh(transformNode)) {
+        mesh = transformNode.sourceMesh;
+    }
+    const aggregate = new PhysicsAggregate(transformNode, data.shape.type, {
+        mesh,
+        mass: data.massProperties.mass,
+    });
+    aggregate.body.setMassProperties({
+        mass: data.massProperties.mass,
+        inertia: data.massProperties.inertia ? Vector3.FromArray(data.massProperties.inertia) : undefined,
+        centerOfMass: data.massProperties.centerOfMass ? Vector3.FromArray(data.massProperties.centerOfMass) : undefined,
+        inertiaOrientation: data.massProperties.inertiaOrientation ? Quaternion.FromArray(data.massProperties.inertiaOrientation) : undefined,
+    });
+    aggregate.shape.density = data.shape.density;
+    aggregate.body.setMotionType(data.body.motionType);
+    aggregate.shape.material = data.material;
+    transformNode.physicsAggregate = aggregate;
+    transformNode.metadata.physicsAggregate = undefined;
+}
+//# sourceMappingURL=physics.js.map

package/build/src/loading/rendering.js

@@ -0,0 +1,30 @@
+import { vlsPostProcessCameraConfigurations } from "../rendering/vls";
+import { ssrRenderingPipelineCameraConfigurations } from "../rendering/ssr";
+import { ssaoRenderingPipelineCameraConfigurations } from "../rendering/ssao";
+import { motionBlurPostProcessCameraConfigurations } from "../rendering/motion-blur";
+import { defaultPipelineCameraConfigurations } from "../rendering/default-pipeline";
+export 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);
+        }
+    });
+}
+//# sourceMappingURL=rendering.js.map

package/build/src/loading/script.js

@@ -0,0 +1,35 @@
+import { applyDecorators } from "../decorators/apply";
+export function applyScriptForObject(scene, object, scriptsMap, rootUrl) {
+    if (!object.metadata) {
+        return;
+    }
+    object.metadata.scripts?.forEach((script) => {
+        if (!script.enabled) {
+            return;
+        }
+        const exports = scriptsMap[script.key];
+        if (!exports) {
+            return;
+        }
+        if (exports.default) {
+            const instance = new exports.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 (exports.onStart) {
+                scene.onBeforeRenderObservable.addOnce(() => exports.onStart(object));
+            }
+            if (exports.onUpdate) {
+                scene.onBeforeRenderObservable.add(() => exports.onUpdate(object));
+            }
+        }
+    });
+    object.metadata.scripts = undefined;
+}
+//# sourceMappingURL=script.js.map

package/build/src/loading/sound.js

@@ -0,0 +1,14 @@
+import { SceneComponentConstants } from "@babylonjs/core/sceneComponent";
+import { GetParser, AddParser } from "@babylonjs/core/Loading/Plugins/babylonFileParser.function";
+const audioParser = GetParser(SceneComponentConstants.NAME_AUDIO);
+AddParser(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;
+        }
+    });
+});
+//# sourceMappingURL=sound.js.map

package/build/{texture.js → src/loading/texture.js}

@@ -1,26 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const decorators_serialization_1 = require("@babylonjs/core/Misc/decorators.serialization");
-const scalar_1 = require("./tools/scalar");
+import { SerializationHelper } from "@babylonjs/core/Misc/decorators.serialization";
+import { getPowerOfTwoUntil } from "../tools/scalar";
 /**
  * Defines the reference to the original texture parser function.
  */
-const textureParser = decorators_serialization_1.SerializationHelper._TextureParser;
-decorators_serialization_1.SerializationHelper._TextureParser = (sourceProperty, scene, rootUrl) => {
+const textureParser = SerializationHelper._TextureParser;
+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 === (0, scalar_1.getPowerOfTwoUntil)(width) || height === (0, scalar_1.getPowerOfTwoUntil)(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 = (0, scalar_1.getPowerOfTwoUntil)(midWidth);
-                midHeight = (0, scalar_1.getPowerOfTwoUntil)(midHeight);
+                midWidth = getPowerOfTwoUntil(midWidth);
+                midHeight = getPowerOfTwoUntil(midHeight);
             }
             suffix = `_${midWidth}_${midHeight}`;
             break;
@@ -28,8 +26,8 @@ decorators_serialization_1.SerializationHelper._TextureParser = (sourceProperty,
             let lowWidth = (width * 0.33) >> 0;
             let lowHeight = (height * 0.33) >> 0;
             if (isPowerOfTwo) {
-                lowWidth = (0, scalar_1.getPowerOfTwoUntil)(lowWidth);
-                lowHeight = (0, scalar_1.getPowerOfTwoUntil)(lowHeight);
+                lowWidth = getPowerOfTwoUntil(lowWidth);
+                lowHeight = getPowerOfTwoUntil(lowHeight);
             }
             suffix = `_${lowWidth}_${lowHeight}`;
             break;

package/build/{rendering → src/rendering}/default-pipeline.js

@@ -1,32 +1,32 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseDefaultRenderingPipeline = exports.serializeDefaultRenderingPipeline = exports.createDefaultRenderingPipeline = exports.disposeDefaultRenderingPipeline = exports.getDefaultRenderingPipeline = void 0;
-const defaultRenderingPipeline_1 = require("@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/defaultRenderingPipeline");
+import { Color4 } from "@babylonjs/core/Maths/math.color";
+import { Vector2 } from "@babylonjs/core/Maths/math.vector";
+import { DefaultRenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/defaultRenderingPipeline";
 let defaultRenderingPipeline = null;
+/**
+ * Defines the configuration of the default rendering pipeline per camera.
+ */
+export const defaultPipelineCameraConfigurations = new Map();
 /**
  * Returns the reference to the default rendering pipeline if exists.
  */
-function getDefaultRenderingPipeline() {
+export function getDefaultRenderingPipeline() {
     return defaultRenderingPipeline;
 }
-exports.getDefaultRenderingPipeline = getDefaultRenderingPipeline;
-function disposeDefaultRenderingPipeline() {
+export function disposeDefaultRenderingPipeline() {
     if (defaultRenderingPipeline) {
         defaultRenderingPipeline.dispose();
         defaultRenderingPipeline = null;
     }
 }
-exports.disposeDefaultRenderingPipeline = disposeDefaultRenderingPipeline;
-function createDefaultRenderingPipeline(scene, camera) {
-    defaultRenderingPipeline = new defaultRenderingPipeline_1.DefaultRenderingPipeline("DefaultRenderingPipeline", true, scene, [camera]);
+export function createDefaultRenderingPipeline(scene, camera) {
+    defaultRenderingPipeline = new DefaultRenderingPipeline("DefaultRenderingPipeline", true, scene, [camera]);
     defaultRenderingPipeline.samples = 4;
     defaultRenderingPipeline.depthOfField.lensSize = 512;
     defaultRenderingPipeline.depthOfField.fStop = 0.25;
     defaultRenderingPipeline.depthOfField.focusDistance = 55_000;
     return defaultRenderingPipeline;
 }
-exports.createDefaultRenderingPipeline = createDefaultRenderingPipeline;
-function serializeDefaultRenderingPipeline() {
+export function serializeDefaultRenderingPipeline() {
     if (!defaultRenderingPipeline) {
         return null;
     }
@@ -58,10 +58,21 @@ function serializeDefaultRenderingPipeline() {
         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,
     };
 }
-exports.serializeDefaultRenderingPipeline = serializeDefaultRenderingPipeline;
-function parseDefaultRenderingPipeline(scene, camera, data) {
+export function parseDefaultRenderingPipeline(scene, camera, data) {
     if (defaultRenderingPipeline) {
         return defaultRenderingPipeline;
     }
@@ -77,6 +88,10 @@ function parseDefaultRenderingPipeline(scene, camera, data) {
         pipeline.imageProcessing.toneMappingType = data.toneMappingType;
         pipeline.imageProcessing.ditheringEnabled = data.ditheringEnabled;
         pipeline.imageProcessing.ditheringIntensity = data.ditheringIntensity;
+        // Since v5.0.0-alpha.9
+        pipeline.imageProcessing.vignetteEnabled = data.vignetteEnabled ?? false;
+        pipeline.imageProcessing.vignetteColor = Color4.FromArray(data.vignetteColor ?? [0, 0, 0]);
+        pipeline.imageProcessing.vignetteWeight = data.vignetteWeight ?? 0.3;
     }
     pipeline.bloomEnabled = data.bloomEnabled;
     pipeline.bloomThreshold = data.bloomThreshold;
@@ -95,7 +110,17 @@ function parseDefaultRenderingPipeline(scene, camera, data) {
     pipeline.depthOfField.fStop = data.fStop;
     pipeline.depthOfField.focusDistance = data.focusDistance;
     pipeline.depthOfField.focalLength = data.focalLength;
+    // Since v5.0.0-alpha.9
+    pipeline.chromaticAberrationEnabled = data.chromaticAberrationEnabled ?? false;
+    pipeline.chromaticAberration.aberrationAmount = data.aberrationAmount ?? 10;
+    pipeline.chromaticAberration.radialIntensity = data.radialIntensity ?? 1;
+    pipeline.chromaticAberration.direction = Vector2.FromArray(data.direction ?? [0, 0]);
+    pipeline.chromaticAberration.centerPosition = 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;
 }
-exports.parseDefaultRenderingPipeline = parseDefaultRenderingPipeline;
 //# sourceMappingURL=default-pipeline.js.map

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

@@ -0,0 +1,42 @@
+import { MotionBlurPostProcess } from "@babylonjs/core/PostProcesses/motionBlurPostProcess";
+let motionBlurPostProcess = null;
+/**
+ * Defines the configuration of the motion blur post-process per camera.
+ */
+export const motionBlurPostProcessCameraConfigurations = new Map();
+export function getMotionBlurPostProcess() {
+    return motionBlurPostProcess;
+}
+export function disposeMotionBlurPostProcess() {
+    if (motionBlurPostProcess) {
+        motionBlurPostProcess.dispose();
+        motionBlurPostProcess = null;
+    }
+}
+export function createMotionBlurPostProcess(scene, camera) {
+    motionBlurPostProcess = new MotionBlurPostProcess("MotionBlurPostProcess", scene, 1.0, camera);
+    motionBlurPostProcess.motionStrength = 1.0;
+    motionBlurPostProcess.isObjectBased = true;
+    return motionBlurPostProcess;
+}
+export function serializeMotionBlurPostProcess() {
+    if (!motionBlurPostProcess) {
+        return null;
+    }
+    return {
+        isObjectBased: motionBlurPostProcess.isObjectBased,
+        motionStrength: motionBlurPostProcess.motionStrength,
+        motionBlurSamples: motionBlurPostProcess.motionBlurSamples,
+    };
+}
+export 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;
+}
+//# sourceMappingURL=motion-blur.js.map

package/build/{rendering → src/rendering}/ssao.js

@@ -1,26 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSSAO2RenderingPipeline = exports.serializeSSAO2RenderingPipeline = exports.createSSAO2RenderingPipeline = exports.disposeSSAO2RenderingPipeline = exports.getSSAO2RenderingPipeline = void 0;
-const ssao2RenderingPipeline_1 = require("@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/ssao2RenderingPipeline");
+import { SSAO2RenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/ssao2RenderingPipeline";
 let ssaoRenderingPipeline = null;
-function getSSAO2RenderingPipeline() {
+/**
+ * Defines the configuration of the SSAO rendering pipeline per camera.
+ */
+export const ssaoRenderingPipelineCameraConfigurations = new Map();
+export function getSSAO2RenderingPipeline() {
     return ssaoRenderingPipeline;
 }
-exports.getSSAO2RenderingPipeline = getSSAO2RenderingPipeline;
-function disposeSSAO2RenderingPipeline() {
+export function disposeSSAO2RenderingPipeline() {
     if (ssaoRenderingPipeline) {
         ssaoRenderingPipeline.dispose();
         ssaoRenderingPipeline = null;
     }
 }
-exports.disposeSSAO2RenderingPipeline = disposeSSAO2RenderingPipeline;
-function createSSAO2RenderingPipeline(scene, camera) {
-    ssaoRenderingPipeline = new ssao2RenderingPipeline_1.SSAO2RenderingPipeline("SSAO2RenderingPipeline", scene, 1.0, [camera]);
+export function createSSAO2RenderingPipeline(scene, camera) {
+    ssaoRenderingPipeline = new SSAO2RenderingPipeline("SSAO2RenderingPipeline", scene, 1.0, [camera]);
     ssaoRenderingPipeline.samples = 4;
     return ssaoRenderingPipeline;
 }
-exports.createSSAO2RenderingPipeline = createSSAO2RenderingPipeline;
-function serializeSSAO2RenderingPipeline() {
+export function serializeSSAO2RenderingPipeline() {
     if (!ssaoRenderingPipeline) {
         return null;
     }
@@ -39,8 +37,7 @@ function serializeSSAO2RenderingPipeline() {
         expensiveBlur: ssaoRenderingPipeline.expensiveBlur,
     };
 }
-exports.serializeSSAO2RenderingPipeline = serializeSSAO2RenderingPipeline;
-function parseSSAO2RenderingPipeline(scene, camera, data) {
+export function parseSSAO2RenderingPipeline(scene, camera, data) {
     if (ssaoRenderingPipeline) {
         return ssaoRenderingPipeline;
     }
@@ -59,5 +56,4 @@ function parseSSAO2RenderingPipeline(scene, camera, data) {
     pipeline.expensiveBlur = data.expensiveBlur;
     return pipeline;
 }
-exports.parseSSAO2RenderingPipeline = parseSSAO2RenderingPipeline;
 //# sourceMappingURL=ssao.js.map

package/build/{rendering → src/rendering}/ssr.js

@@ -1,26 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSSRRenderingPipeline = exports.serializeSSRRenderingPipeline = exports.createSSRRenderingPipeline = exports.disposeSSRRenderingPipeline = exports.getSSRRenderingPipeline = void 0;
-const ssrRenderingPipeline_1 = require("@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/ssrRenderingPipeline");
+import { SSRRenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/ssrRenderingPipeline";
 let ssrRenderingPipeline = null;
-function getSSRRenderingPipeline() {
+/**
+ * Defines the configuration of the ssr rendering pipeline per camera.
+ */
+export const ssrRenderingPipelineCameraConfigurations = new Map();
+export function getSSRRenderingPipeline() {
     return ssrRenderingPipeline;
 }
-exports.getSSRRenderingPipeline = getSSRRenderingPipeline;
-function disposeSSRRenderingPipeline() {
+export function disposeSSRRenderingPipeline() {
     if (ssrRenderingPipeline) {
         ssrRenderingPipeline.dispose();
         ssrRenderingPipeline = null;
     }
 }
-exports.disposeSSRRenderingPipeline = disposeSSRRenderingPipeline;
-function createSSRRenderingPipeline(scene, camera) {
-    ssrRenderingPipeline = new ssrRenderingPipeline_1.SSRRenderingPipeline("SSRRenderingPipeline", scene, [camera]);
+export function createSSRRenderingPipeline(scene, camera) {
+    ssrRenderingPipeline = new SSRRenderingPipeline("SSRRenderingPipeline", scene, [camera]);
     ssrRenderingPipeline.samples = 4;
     return ssrRenderingPipeline;
 }
-exports.createSSRRenderingPipeline = createSSRRenderingPipeline;
-function serializeSSRRenderingPipeline() {
+export function serializeSSRRenderingPipeline() {
     if (!ssrRenderingPipeline) {
         return null;
     }
@@ -48,8 +46,7 @@ function serializeSSRRenderingPipeline() {
         backfaceDepthTextureDownsample: ssrRenderingPipeline.backfaceDepthTextureDownsample,
     };
 }
-exports.serializeSSRRenderingPipeline = serializeSSRRenderingPipeline;
-function parseSSRRenderingPipeline(scene, camera, data) {
+export function parseSSRRenderingPipeline(scene, camera, data) {
     if (ssrRenderingPipeline) {
         return ssrRenderingPipeline;
     }
@@ -77,5 +74,4 @@ function parseSSRRenderingPipeline(scene, camera, data) {
     pipeline.backfaceDepthTextureDownsample = data.backfaceDepthTextureDownsample;
     return pipeline;
 }
-exports.parseSSRRenderingPipeline = parseSSRRenderingPipeline;
 //# sourceMappingURL=ssr.js.map

package/build/src/rendering/tools.js

@@ -0,0 +1,51 @@
+import { disposeVLSPostProcess, parseVLSPostProcess, serializeVLSPostProcess, vlsPostProcessCameraConfigurations } from "./vls";
+import { disposeSSRRenderingPipeline, parseSSRRenderingPipeline, serializeSSRRenderingPipeline, ssrRenderingPipelineCameraConfigurations } from "./ssr";
+import { disposeSSAO2RenderingPipeline, parseSSAO2RenderingPipeline, serializeSSAO2RenderingPipeline, ssaoRenderingPipelineCameraConfigurations } from "./ssao";
+import { disposeMotionBlurPostProcess, motionBlurPostProcessCameraConfigurations, parseMotionBlurPostProcess, serializeMotionBlurPostProcess } from "./motion-blur";
+import { defaultPipelineCameraConfigurations, disposeDefaultRenderingPipeline, parseDefaultRenderingPipeline, serializeDefaultRenderingPipeline } from "./default-pipeline";
+/**
+ * Saves the rendering configurations for the given camera. This is useful to restore the rendering configurations
+ * when the camera is re-activated (typically using the preview panel toolbar).
+ * @param camera defines the reference to the camera to save its rendering configurations.
+ */
+export function saveRenderingConfigurationForCamera(camera) {
+    ssaoRenderingPipelineCameraConfigurations.set(camera, serializeSSAO2RenderingPipeline());
+    vlsPostProcessCameraConfigurations.set(camera, serializeVLSPostProcess());
+    ssrRenderingPipelineCameraConfigurations.set(camera, serializeSSRRenderingPipeline());
+    motionBlurPostProcessCameraConfigurations.set(camera, serializeMotionBlurPostProcess());
+    defaultPipelineCameraConfigurations.set(camera, serializeDefaultRenderingPipeline());
+}
+/**
+ * Applies the post-processes configurations for the given camera. Rendering configurations (motion blur, ssao, etc.) are
+ * saved per-camera and can be applied on demand using this function.
+ * Previous post-processes configurations are disposed before applying the new ones.
+ * @param camera defines the reference to the camera to apply its rendering configurations.
+ */
+export function applyRenderingConfigurationForCamera(camera) {
+    disposeSSAO2RenderingPipeline();
+    disposeVLSPostProcess(camera.getScene());
+    disposeSSRRenderingPipeline();
+    disposeMotionBlurPostProcess();
+    disposeDefaultRenderingPipeline();
+    const ssao2RenderingPipeline = ssaoRenderingPipelineCameraConfigurations.get(camera);
+    if (ssao2RenderingPipeline) {
+        parseSSAO2RenderingPipeline(camera.getScene(), camera, ssao2RenderingPipeline);
+    }
+    const vlsPostProcess = vlsPostProcessCameraConfigurations.get(camera);
+    if (vlsPostProcess) {
+        parseVLSPostProcess(camera.getScene(), vlsPostProcess);
+    }
+    const ssrRenderingPipeline = ssrRenderingPipelineCameraConfigurations.get(camera);
+    if (ssrRenderingPipeline) {
+        parseSSRRenderingPipeline(camera.getScene(), camera, ssrRenderingPipeline);
+    }
+    const motionBlurPostProcess = motionBlurPostProcessCameraConfigurations.get(camera);
+    if (motionBlurPostProcess) {
+        parseMotionBlurPostProcess(camera.getScene(), camera, motionBlurPostProcess);
+    }
+    const defaultRenderingPipeline = defaultPipelineCameraConfigurations.get(camera);
+    if (defaultRenderingPipeline) {
+        parseDefaultRenderingPipeline(camera.getScene(), camera, defaultRenderingPipeline);
+    }
+}
+//# sourceMappingURL=tools.js.map

package/build/src/rendering/vls.js

@@ -0,0 +1,57 @@
+import { Vector3 } from "@babylonjs/core/Maths/math.vector";
+import { Texture } from "@babylonjs/core/Materials/Textures/texture";
+import { VolumetricLightScatteringPostProcess } from "@babylonjs/core/PostProcesses/volumetricLightScatteringPostProcess";
+import { isMesh } from "../tools/guards";
+let vlsPostProcess = null;
+/**
+ * Defines the configuration of the motion blur post-process per camera.
+ */
+export const vlsPostProcessCameraConfigurations = new Map();
+export function getVLSPostProcess() {
+    return vlsPostProcess;
+}
+export function disposeVLSPostProcess(scene) {
+    if (vlsPostProcess && scene.activeCamera) {
+        vlsPostProcess.dispose(scene.activeCamera);
+        vlsPostProcess = null;
+    }
+}
+export function createVLSPostProcess(scene, mesh) {
+    mesh ??= scene.meshes.find((mesh) => isMesh(mesh));
+    vlsPostProcess = new VolumetricLightScatteringPostProcess("VolumetricLightScatteringPostProcess", 1.0, scene.activeCamera, mesh, 100, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false);
+    return vlsPostProcess;
+}
+export 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(),
+    };
+}
+export function parseVLSPostProcess(scene, data) {
+    let mesh = null;
+    if (data.meshId) {
+        const result = scene.getMeshById(data.meshId);
+        if (result && isMesh(result)) {
+            mesh = result;
+        }
+    }
+    const vlsPostProcess = createVLSPostProcess(scene, mesh);
+    vlsPostProcess.exposure = data.exposure;
+    vlsPostProcess.decay = data.decay;
+    vlsPostProcess.weight = data.weight;
+    vlsPostProcess.density = data.density;
+    vlsPostProcess.invert = data.invert;
+    vlsPostProcess.useCustomMeshPosition = data.useCustomMeshPosition;
+    vlsPostProcess.customMeshPosition.copyFrom(Vector3.FromArray(data.customMeshPosition));
+    return vlsPostProcess;
+}
+//# sourceMappingURL=vls.js.map

package/build/src/script.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=script.js.map