babylonjs-editor-tools 0.0.1 → 0.0.3

package/build/index.js

@@ -16,4 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./loader"), exports);
 __exportStar(require("./texture"), exports);
+__exportStar(require("./rendering/ssao"), exports);
+__exportStar(require("./rendering/ssr"), exports);
+__exportStar(require("./rendering/motion-blur"), exports);
+__exportStar(require("./rendering/default-pipeline"), exports);
 //# sourceMappingURL=index.js.map

package/build/loader.js

@@ -2,33 +2,51 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadScriptsFor = exports.loadScene = void 0;
 const sceneLoader_1 = require("@babylonjs/core/Loading/sceneLoader");
-async function loadScene(rootUrl, sceneFilename, scene) {
+const ssr_1 = require("./rendering/ssr");
+const ssao_1 = require("./rendering/ssao");
+const motion_blur_1 = require("./rendering/motion-blur");
+const default_pipeline_1 = require("./rendering/default-pipeline");
+async function loadScene(rootUrl, sceneFilename, scene, scriptsMap) {
     await sceneLoader_1.SceneLoader.AppendAsync(rootUrl, sceneFilename, scene);
-    loadScriptsFor(scene, scene);
-    scene.transformNodes.forEach((transformNode) => loadScriptsFor(scene, transformNode));
-    scene.meshes.forEach((mesh) => loadScriptsFor(scene, mesh));
-    scene.lights.forEach((light) => loadScriptsFor(scene, light));
-    scene.cameras.forEach((camera) => loadScriptsFor(scene, camera));
+    if (scene.metadata?.rendering) {
+        const camera = scene.activeCamera ?? scene.cameras[0];
+        if (scene.metadata.rendering.ssao2RenderingPipeline) {
+            (0, ssao_1.parseSSAO2RenderingPipeline)(scene, camera, scene.metadata.rendering.ssao2RenderingPipeline);
+        }
+        if (scene.metadata.rendering.ssrRenderingPipeline) {
+            (0, ssr_1.parseSSRRenderingPipeline)(scene, camera, scene.metadata.rendering.ssrRenderingPipeline);
+        }
+        if (scene.metadata.rendering.motionBlurPostProcess) {
+            (0, motion_blur_1.parseMotionBlurPostProcess)(scene, camera, scene.metadata.rendering.motionBlurPostProcess);
+        }
+        if (scene.metadata.rendering.defaultRenderingPipeline) {
+            (0, default_pipeline_1.parseDefaultRenderingPipeline)(scene, camera, scene.metadata.rendering.defaultRenderingPipeline);
+        }
+    }
+    loadScriptsFor(scene, scene, scriptsMap);
+    scene.transformNodes.forEach((transformNode) => loadScriptsFor(scene, transformNode, scriptsMap));
+    scene.meshes.forEach((mesh) => loadScriptsFor(scene, mesh, scriptsMap));
+    scene.lights.forEach((light) => loadScriptsFor(scene, light, scriptsMap));
+    scene.cameras.forEach((camera) => loadScriptsFor(scene, camera, scriptsMap));
 }
 exports.loadScene = loadScene;
-function loadScriptsFor(scene, object) {
+function loadScriptsFor(scene, object, scriptsMap) {
     if (!object.metadata) {
         return;
     }
-    const map = require("@/scripts").scriptsMap;
     object.metadata.scripts?.forEach((script) => {
         if (!script.enabled) {
             return;
         }
-        const exports = map[script.key];
+        const exports = scriptsMap[script.key];
         if (!exports) {
             return;
         }
         if (exports.default) {
             const instance = new exports.default(object);
-            scene.onBeforeRenderObservable.addOnce(() => {
-                instance.onStart?.();
-            });
+            if (instance.onStart) {
+                scene.onBeforeRenderObservable.addOnce(() => instance.onStart());
+            }
             if (instance.onUpdate) {
                 scene.onBeforeRenderObservable.add(() => instance.onUpdate());
             }

package/build/rendering/default-pipeline.js

@@ -0,0 +1,98 @@
+"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");
+let defaultRenderingPipeline = null;
+/**
+ * Returns the reference to the default rendering pipeline if exists.
+ */
+function getDefaultRenderingPipeline() {
+    return defaultRenderingPipeline;
+}
+exports.getDefaultRenderingPipeline = getDefaultRenderingPipeline;
+function disposeDefaultRenderingPipeline() {
+    if (defaultRenderingPipeline) {
+        defaultRenderingPipeline.dispose();
+        defaultRenderingPipeline = null;
+    }
+}
+exports.disposeDefaultRenderingPipeline = disposeDefaultRenderingPipeline;
+function createDefaultRenderingPipeline(scene, camera) {
+    defaultRenderingPipeline = new defaultRenderingPipeline_1.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() {
+    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,
+    };
+}
+exports.serializeDefaultRenderingPipeline = serializeDefaultRenderingPipeline;
+function parseDefaultRenderingPipeline(scene, camera, data) {
+    const defaultRenderingPipeline = createDefaultRenderingPipeline(scene, camera);
+    defaultRenderingPipeline.samples = data.samples;
+    defaultRenderingPipeline.fxaaEnabled = data.fxaaEnabled;
+    defaultRenderingPipeline.imageProcessingEnabled = data.imageProcessingEnabled;
+    if (defaultRenderingPipeline.imageProcessing) {
+        defaultRenderingPipeline.imageProcessing.exposure = data.exposure;
+        defaultRenderingPipeline.imageProcessing.contrast = data.contrast;
+        defaultRenderingPipeline.imageProcessing.fromLinearSpace = data.fromLinearSpace;
+        defaultRenderingPipeline.imageProcessing.toneMappingEnabled = data.toneMappingEnabled;
+        defaultRenderingPipeline.imageProcessing.toneMappingType = data.toneMappingType;
+        defaultRenderingPipeline.imageProcessing.ditheringEnabled = data.ditheringEnabled;
+        defaultRenderingPipeline.imageProcessing.ditheringIntensity = data.ditheringIntensity;
+    }
+    defaultRenderingPipeline.bloomEnabled = data.bloomEnabled;
+    defaultRenderingPipeline.bloomThreshold = data.bloomThreshold;
+    defaultRenderingPipeline.bloomWeight = data.bloomWeight;
+    defaultRenderingPipeline.bloomScale = data.bloomScale;
+    defaultRenderingPipeline.bloomKernel = data.bloomKernel;
+    defaultRenderingPipeline.sharpenEnabled = data.sharpenEnabled;
+    defaultRenderingPipeline.sharpen.edgeAmount = data.sharpenEdgeAmount;
+    defaultRenderingPipeline.sharpen.colorAmount = data.sharpenColorAmount;
+    defaultRenderingPipeline.grainEnabled = data.grainEnabled;
+    defaultRenderingPipeline.grain.intensity = data.grainIntensity;
+    defaultRenderingPipeline.grain.animated = data.grainAnimated;
+    defaultRenderingPipeline.depthOfFieldEnabled = data.depthOfFieldEnabled;
+    defaultRenderingPipeline.depthOfFieldBlurLevel = data.depthOfFieldBlurLevel;
+    defaultRenderingPipeline.depthOfField.lensSize = data.lensSize;
+    defaultRenderingPipeline.depthOfField.fStop = data.fStop;
+    defaultRenderingPipeline.depthOfField.focusDistance = data.focusDistance;
+    defaultRenderingPipeline.depthOfField.focalLength = data.focalLength;
+    return defaultRenderingPipeline;
+}
+exports.parseDefaultRenderingPipeline = parseDefaultRenderingPipeline;
+//# sourceMappingURL=default-pipeline.js.map

package/build/rendering/default.js

@@ -0,0 +1,98 @@
+"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");
+let defaultRenderingPipeline = null;
+/**
+ * Returns the reference to the default rendering pipeline if exists.
+ */
+function getDefaultRenderingPipeline() {
+    return defaultRenderingPipeline;
+}
+exports.getDefaultRenderingPipeline = getDefaultRenderingPipeline;
+function disposeDefaultRenderingPipeline() {
+    if (defaultRenderingPipeline) {
+        defaultRenderingPipeline.dispose();
+        defaultRenderingPipeline = null;
+    }
+}
+exports.disposeDefaultRenderingPipeline = disposeDefaultRenderingPipeline;
+function createDefaultRenderingPipeline(scene, camera) {
+    defaultRenderingPipeline = new defaultRenderingPipeline_1.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() {
+    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,
+    };
+}
+exports.serializeDefaultRenderingPipeline = serializeDefaultRenderingPipeline;
+function parseDefaultRenderingPipeline(scene, camera, data) {
+    const defaultRenderingPipeline = createDefaultRenderingPipeline(scene, camera);
+    defaultRenderingPipeline.samples = data.samples;
+    defaultRenderingPipeline.fxaaEnabled = data.fxaaEnabled;
+    defaultRenderingPipeline.imageProcessingEnabled = data.imageProcessingEnabled;
+    if (defaultRenderingPipeline.imageProcessing) {
+        defaultRenderingPipeline.imageProcessing.exposure = data.exposure;
+        defaultRenderingPipeline.imageProcessing.contrast = data.contrast;
+        defaultRenderingPipeline.imageProcessing.fromLinearSpace = data.fromLinearSpace;
+        defaultRenderingPipeline.imageProcessing.toneMappingEnabled = data.toneMappingEnabled;
+        defaultRenderingPipeline.imageProcessing.toneMappingType = data.toneMappingType;
+        defaultRenderingPipeline.imageProcessing.ditheringEnabled = data.ditheringEnabled;
+        defaultRenderingPipeline.imageProcessing.ditheringIntensity = data.ditheringIntensity;
+    }
+    defaultRenderingPipeline.bloomEnabled = data.bloomEnabled;
+    defaultRenderingPipeline.bloomThreshold = data.bloomThreshold;
+    defaultRenderingPipeline.bloomWeight = data.bloomWeight;
+    defaultRenderingPipeline.bloomScale = data.bloomScale;
+    defaultRenderingPipeline.bloomKernel = data.bloomKernel;
+    defaultRenderingPipeline.sharpenEnabled = data.sharpenEnabled;
+    defaultRenderingPipeline.sharpen.edgeAmount = data.sharpenEdgeAmount;
+    defaultRenderingPipeline.sharpen.colorAmount = data.sharpenColorAmount;
+    defaultRenderingPipeline.grainEnabled = data.grainEnabled;
+    defaultRenderingPipeline.grain.intensity = data.grainIntensity;
+    defaultRenderingPipeline.grain.animated = data.grainAnimated;
+    defaultRenderingPipeline.depthOfFieldEnabled = data.depthOfFieldEnabled;
+    defaultRenderingPipeline.depthOfFieldBlurLevel = data.depthOfFieldBlurLevel;
+    defaultRenderingPipeline.depthOfField.lensSize = data.lensSize;
+    defaultRenderingPipeline.depthOfField.fStop = data.fStop;
+    defaultRenderingPipeline.depthOfField.focusDistance = data.focusDistance;
+    defaultRenderingPipeline.depthOfField.focalLength = data.focalLength;
+    return defaultRenderingPipeline;
+}
+exports.parseDefaultRenderingPipeline = parseDefaultRenderingPipeline;
+//# sourceMappingURL=default.js.map

package/build/rendering/motion-blur.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMotionBlurPostProcess = exports.serializeMotionBlurPostProcess = exports.createMotionBlurPostProcess = exports.disposeMotionBlurPostProcess = exports.getMotionBlurPostProcess = void 0;
+const motionBlurPostProcess_1 = require("@babylonjs/core/PostProcesses/motionBlurPostProcess");
+let motionBlurPostProcess = null;
+function getMotionBlurPostProcess() {
+    return motionBlurPostProcess;
+}
+exports.getMotionBlurPostProcess = getMotionBlurPostProcess;
+function disposeMotionBlurPostProcess() {
+    if (motionBlurPostProcess) {
+        motionBlurPostProcess.dispose();
+        motionBlurPostProcess = null;
+    }
+}
+exports.disposeMotionBlurPostProcess = disposeMotionBlurPostProcess;
+function createMotionBlurPostProcess(scene, camera) {
+    motionBlurPostProcess = new motionBlurPostProcess_1.MotionBlurPostProcess("MotionBlurPostProcess", scene, 1.0, camera);
+    motionBlurPostProcess.motionStrength = 1.0;
+    motionBlurPostProcess.isObjectBased = true;
+    return motionBlurPostProcess;
+}
+exports.createMotionBlurPostProcess = createMotionBlurPostProcess;
+function serializeMotionBlurPostProcess() {
+    if (!motionBlurPostProcess) {
+        return null;
+    }
+    return {
+        isObjectBased: motionBlurPostProcess.isObjectBased,
+        motionStrength: motionBlurPostProcess.motionStrength,
+        motionBlurSamples: motionBlurPostProcess.motionBlurSamples,
+    };
+}
+exports.serializeMotionBlurPostProcess = serializeMotionBlurPostProcess;
+function parseMotionBlurPostProcess(scene, camera, data) {
+    const motionBlurPostProcess = createMotionBlurPostProcess(scene, camera);
+    motionBlurPostProcess.isObjectBased = data.isObjectBased;
+    motionBlurPostProcess.motionStrength = data.motionStrength;
+    motionBlurPostProcess.motionBlurSamples = data.motionBlurSamples;
+    return motionBlurPostProcess;
+}
+exports.parseMotionBlurPostProcess = parseMotionBlurPostProcess;
+//# sourceMappingURL=motion-blur.js.map

package/build/rendering/ssao.js

@@ -0,0 +1,60 @@
+"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");
+let ssaoRenderingPipeline = null;
+function getSSAO2RenderingPipeline() {
+    return ssaoRenderingPipeline;
+}
+exports.getSSAO2RenderingPipeline = getSSAO2RenderingPipeline;
+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]);
+    ssaoRenderingPipeline.samples = 4;
+    return ssaoRenderingPipeline;
+}
+exports.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,
+    };
+}
+exports.serializeSSAO2RenderingPipeline = serializeSSAO2RenderingPipeline;
+function parseSSAO2RenderingPipeline(scene, camera, data) {
+    const ssao2RenderingPipeline = createSSAO2RenderingPipeline(scene, camera);
+    ssao2RenderingPipeline.radius = data.radius;
+    ssao2RenderingPipeline.totalStrength = data.totalStrength;
+    ssao2RenderingPipeline.samples = data.samples;
+    ssao2RenderingPipeline.maxZ = data.maxZ;
+    ssao2RenderingPipeline.minZAspect = data.minZAspect;
+    ssao2RenderingPipeline.epsilon = data.epsilon;
+    ssao2RenderingPipeline.textureSamples = data.textureSamples;
+    ssao2RenderingPipeline.bypassBlur = data.bypassBlur;
+    ssao2RenderingPipeline.bilateralSamples = data.bilateralSamples;
+    ssao2RenderingPipeline.bilateralSoften = data.bilateralSoften;
+    ssao2RenderingPipeline.bilateralTolerance = data.bilateralTolerance;
+    ssao2RenderingPipeline.expensiveBlur = data.expensiveBlur;
+    return ssao2RenderingPipeline;
+}
+exports.parseSSAO2RenderingPipeline = parseSSAO2RenderingPipeline;
+//# sourceMappingURL=ssao.js.map

package/build/rendering/ssr.js

@@ -0,0 +1,78 @@
+"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");
+let ssrRenderingPipeline = null;
+function getSSRRenderingPipeline() {
+    return ssrRenderingPipeline;
+}
+exports.getSSRRenderingPipeline = getSSRRenderingPipeline;
+function disposeSSRRenderingPipeline() {
+    if (ssrRenderingPipeline) {
+        ssrRenderingPipeline.dispose();
+        ssrRenderingPipeline = null;
+    }
+}
+exports.disposeSSRRenderingPipeline = disposeSSRRenderingPipeline;
+function createSSRRenderingPipeline(scene, camera) {
+    ssrRenderingPipeline = new ssrRenderingPipeline_1.SSRRenderingPipeline("SSRRenderingPipeline", scene, [camera]);
+    ssrRenderingPipeline.samples = 4;
+    return ssrRenderingPipeline;
+}
+exports.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,
+    };
+}
+exports.serializeSSRRenderingPipeline = serializeSSRRenderingPipeline;
+function parseSSRRenderingPipeline(scene, camera, data) {
+    const ssrRenderingPipeline = createSSRRenderingPipeline(scene, camera);
+    ssrRenderingPipeline.samples = data.samples;
+    ssrRenderingPipeline.step = data.step;
+    ssrRenderingPipeline.thickness = data.thickness;
+    ssrRenderingPipeline.strength = data.strength;
+    ssrRenderingPipeline.reflectionSpecularFalloffExponent = data.reflectionSpecularFalloffExponent;
+    ssrRenderingPipeline.maxSteps = data.maxSteps;
+    ssrRenderingPipeline.maxDistance = data.maxDistance;
+    ssrRenderingPipeline.roughnessFactor = data.roughnessFactor;
+    ssrRenderingPipeline.reflectivityThreshold = data.reflectivityThreshold;
+    ssrRenderingPipeline.blurDispersionStrength = data.blurDispersionStrehgth;
+    ssrRenderingPipeline.clipToFrustum = data.clipToFrustum;
+    ssrRenderingPipeline.enableSmoothReflections = data.enableSmoothReflections;
+    ssrRenderingPipeline.enableAutomaticThicknessComputation = data.enableAutomaticThicknessComputation;
+    ssrRenderingPipeline.attenuateFacingCamera = data.attenuateFacingCamera;
+    ssrRenderingPipeline.attenuateScreenBorders = data.attenuateScreenBorders;
+    ssrRenderingPipeline.attenuateIntersectionDistance = data.attenuateIntersectionDistance;
+    ssrRenderingPipeline.attenuateBackfaceReflection = data.attenuateBackfaceReflection;
+    ssrRenderingPipeline.blurDownsample = data.blurDownsample;
+    ssrRenderingPipeline.selfCollisionNumSkip = data.selfCollisionNumSkip;
+    ssrRenderingPipeline.ssrDownsample = data.ssrDownsample;
+    ssrRenderingPipeline.backfaceDepthTextureDownsample = data.backfaceDepthTextureDownsample;
+    return ssrRenderingPipeline;
+}
+exports.parseSSRRenderingPipeline = parseSSRRenderingPipeline;
+//# sourceMappingURL=ssr.js.map

package/declaration/index.d.ts

@@ -1,2 +1,6 @@
 export * from "./loader";
 export * from "./texture";
+export * from "./rendering/ssao";
+export * from "./rendering/ssr";
+export * from "./rendering/motion-blur";
+export * from "./rendering/default-pipeline";

package/declaration/loader.d.ts

@@ -1,3 +1,9 @@
 import { Scene } from "@babylonjs/core/scene";
-export declare function loadScene(rootUrl: string, sceneFilename: string, scene: Scene): Promise<void>;
-export declare function loadScriptsFor(scene: Scene, object: any): void;
+export type ScriptMap = Record<string, {
+    default?: new (object: any) => {
+        onStart?(): void;
+        onUpdate?(): void;
+    };
+}>;
+export declare function loadScene(rootUrl: string, sceneFilename: string, scene: Scene, scriptsMap: ScriptMap): Promise<void>;
+export declare function loadScriptsFor(scene: Scene, object: any, scriptsMap: ScriptMap): void;

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

@@ -0,0 +1,11 @@
+import { Scene } from "@babylonjs/core/scene";
+import { Camera } from "@babylonjs/core/Cameras/camera";
+import { DefaultRenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/defaultRenderingPipeline";
+/**
+ * Returns the reference to the default rendering pipeline if exists.
+ */
+export declare function getDefaultRenderingPipeline(): DefaultRenderingPipeline | null;
+export declare function disposeDefaultRenderingPipeline(): void;
+export declare function createDefaultRenderingPipeline(scene: Scene, camera: Camera): DefaultRenderingPipeline;
+export declare function serializeDefaultRenderingPipeline(): any;
+export declare function parseDefaultRenderingPipeline(scene: Scene, camera: Camera, data: any): DefaultRenderingPipeline;

package/declaration/rendering/default.d.ts

@@ -0,0 +1,11 @@
+import { Scene } from "@babylonjs/core/scene";
+import { Camera } from "@babylonjs/core/Cameras/camera";
+import { DefaultRenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/defaultRenderingPipeline";
+/**
+ * Returns the reference to the default rendering pipeline if exists.
+ */
+export declare function getDefaultRenderingPipeline(): DefaultRenderingPipeline | null;
+export declare function disposeDefaultRenderingPipeline(): void;
+export declare function createDefaultRenderingPipeline(scene: Scene, camera: Camera): DefaultRenderingPipeline;
+export declare function serializeDefaultRenderingPipeline(): any;
+export declare function parseDefaultRenderingPipeline(scene: Scene, camera: Camera, data: any): DefaultRenderingPipeline;

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

@@ -0,0 +1,8 @@
+import { Scene } from "@babylonjs/core/scene";
+import { Camera } from "@babylonjs/core/Cameras/camera";
+import { MotionBlurPostProcess } from "@babylonjs/core/PostProcesses/motionBlurPostProcess";
+export declare function getMotionBlurPostProcess(): MotionBlurPostProcess | null;
+export declare function disposeMotionBlurPostProcess(): void;
+export declare function createMotionBlurPostProcess(scene: Scene, camera: Camera): MotionBlurPostProcess;
+export declare function serializeMotionBlurPostProcess(): any;
+export declare function parseMotionBlurPostProcess(scene: Scene, camera: Camera, data: any): MotionBlurPostProcess;

package/declaration/rendering/ssao.d.ts

@@ -0,0 +1,8 @@
+import { Scene } from "@babylonjs/core/scene";
+import { Camera } from "@babylonjs/core/Cameras/camera";
+import { SSAO2RenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/ssao2RenderingPipeline";
+export declare function getSSAO2RenderingPipeline(): SSAO2RenderingPipeline | null;
+export declare function disposeSSAO2RenderingPipeline(): void;
+export declare function createSSAO2RenderingPipeline(scene: Scene, camera: Camera): SSAO2RenderingPipeline;
+export declare function serializeSSAO2RenderingPipeline(): any;
+export declare function parseSSAO2RenderingPipeline(scene: Scene, camera: Camera, data: any): SSAO2RenderingPipeline;

package/declaration/rendering/ssr.d.ts

@@ -0,0 +1,8 @@
+import { Scene } from "@babylonjs/core/scene";
+import { Camera } from "@babylonjs/core/Cameras/camera";
+import { SSRRenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/ssrRenderingPipeline";
+export declare function getSSRRenderingPipeline(): SSRRenderingPipeline | null;
+export declare function disposeSSRRenderingPipeline(): void;
+export declare function createSSRRenderingPipeline(scene: Scene, camera: Camera): SSRRenderingPipeline;
+export declare function serializeSSRRenderingPipeline(): any;
+export declare function parseSSRRenderingPipeline(scene: Scene, camera: Camera, data: any): SSRRenderingPipeline;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "babylonjs-editor-tools",
-    "version": "0.0.1",
+    "version": "0.0.3",
     "description": "Babylon.js Editor Tools is a set of tools to help you create, edit and manage your Babylon.js scenes made using the Babylon.JS Editor",
     "productName": "Babylon.js Editor Tools",
     "scripts": {