babylonjs-editor-tools 0.0.3 → 0.0.5

package/build/index.js

@@ -15,7 +15,6 @@ 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);

package/build/light.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureShadowMapRefreshRate = exports.configureShadowMapRenderListPredicate = void 0;
+const math_vector_1 = require("@babylonjs/core/Maths/math.vector");
+const renderTargetTexture_1 = require("@babylonjs/core/Materials/Textures/renderTargetTexture");
+function configureShadowMapRenderListPredicate(scene) {
+    scene.lights.forEach((light) => {
+        const shadowMap = light.getShadowGenerator()?.getShadowMap();
+        if (!shadowMap) {
+            return;
+        }
+        shadowMap.renderListPredicate = (mesh) => {
+            const distance = math_vector_1.Vector3.Distance(mesh.getAbsolutePosition(), light.getAbsolutePosition());
+            return distance <= light.range;
+        };
+    });
+}
+exports.configureShadowMapRenderListPredicate = configureShadowMapRenderListPredicate;
+async function configureShadowMapRefreshRate(scene) {
+    scene.executeWhenReady(() => {
+        scene.lights.forEach((light) => {
+            const shadowMap = light.getShadowGenerator()?.getShadowMap();
+            if (shadowMap) {
+                shadowMap.refreshRate = light.metadata?.refreshRate ?? renderTargetTexture_1.RenderTargetTexture.REFRESHRATE_RENDER_ONEVERYFRAME;
+            }
+        });
+    });
+}
+exports.configureShadowMapRefreshRate = configureShadowMapRefreshRate;
+//# sourceMappingURL=light.js.map

package/build/loader.js

@@ -6,8 +6,13 @@ 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) {
+const light_1 = require("./light");
+require("./texture");
+async function loadScene(rootUrl, sceneFilename, scene, scriptsMap, quality = "high") {
+    scene.loadingQuality = quality;
     await sceneLoader_1.SceneLoader.AppendAsync(rootUrl, sceneFilename, scene);
+    (0, light_1.configureShadowMapRenderListPredicate)(scene);
+    (0, light_1.configureShadowMapRefreshRate)(scene);
     if (scene.metadata?.rendering) {
         const camera = scene.activeCamera ?? scene.cameras[0];
         if (scene.metadata.rendering.ssao2RenderingPipeline) {
@@ -51,6 +56,14 @@ function loadScriptsFor(scene, object, scriptsMap) {
                 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;
 }

package/build/texture.js

@@ -1,81 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startTextureOptimizer = void 0;
-const guards_1 = require("./guards");
-const sceneMap = new Map();
-function startTextureOptimizer(scene) {
-    const engine = scene.getEngine();
-    const existingRenderLoop = sceneMap.get(scene);
-    if (existingRenderLoop) {
-        engine.stopRenderLoop(existingRenderLoop);
+const decorators_serialization_1 = require("@babylonjs/core/Misc/decorators.serialization");
+const scalar_1 = require("./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) => {
+    if (scene.loadingQuality === "high" || !sourceProperty.metadata?.baseSize) {
+        return textureParser(sourceProperty, scene, rootUrl);
     }
-    let time = 0;
-    const renderLoop = () => {
-        const camera = scene.activeCamera;
-        time += engine.getDeltaTime();
-        if (!camera || time < 1000) {
-            return;
-        }
-        scene.meshes.forEach((mesh) => {
-            if (!(0, guards_1.isMesh)(mesh) || !mesh.material) {
-                return;
-            }
-            handleMesh(camera, mesh);
-        });
-        time = 0;
-    };
-    sceneMap.set(scene, renderLoop);
-    engine.runRenderLoop(renderLoop);
-}
-exports.startTextureOptimizer = startTextureOptimizer;
-function handleMesh(camera, mesh) {
-    const material = mesh.material;
-    const textures = material.getActiveTextures();
-    if (!textures.length) {
-        return;
+    const width = sourceProperty.metadata.baseSize.width;
+    const height = sourceProperty.metadata.baseSize.height;
+    let suffix = "";
+    switch (scene.loadingQuality) {
+        case "medium":
+            const midWidth = (0, scalar_1.getPowerOfTwoUntil)(width * 0.66);
+            const midHeight = (0, scalar_1.getPowerOfTwoUntil)(height * 0.66);
+            suffix = `_${midWidth}_${midHeight}`;
+            break;
+        case "low":
+            const lowWidth = (0, scalar_1.getPowerOfTwoUntil)(width * 0.33);
+            const lowHeight = (0, scalar_1.getPowerOfTwoUntil)(height * 0.33);
+            suffix = `_${lowWidth}_${lowHeight}`;
+            break;
     }
-    let isInFrustrum = false;
-    if (mesh.instances.length) {
-        isInFrustrum = [mesh, ...mesh.instances].find((instance) => camera.isInFrustum(instance)) ? true : false;
+    const name = sourceProperty.name;
+    if (!name || !suffix) {
+        return textureParser(sourceProperty, scene, rootUrl);
     }
-    else {
-        isInFrustrum = camera.isInFrustum(mesh);
+    const finalUrl = name.split("/");
+    const filename = finalUrl.pop();
+    if (!filename) {
+        return textureParser(sourceProperty, scene, rootUrl);
     }
-    textures.forEach((texture) => {
-        if (!(0, guards_1.isTexture)(texture) || !texture.getInternalTexture() || !texture.isReady()) {
-            return;
-        }
-        texture.metadata ??= {};
-        texture.metadata.editor ??= {
-            ratio: 1,
-            url: texture.getInternalTexture()?.url,
-        };
-        const url = texture.metadata.editor.url;
-        if (!url) {
-            return;
-        }
-        let ratio = texture.metadata.editor.ratio;
-        if (isInFrustrum && ratio === 1) {
-            return;
-        }
-        let split = url.split("/");
-        const dirname = split.slice(0, -1).join("/");
-        const basename = split[split.length - 1];
-        split = basename.split(".");
-        ratio *= (isInFrustrum ? 2 : 0.5);
-        const width = texture.getBaseSize().width * ratio;
-        const height = texture.getBaseSize().height * ratio;
-        if (!isInFrustrum && (width <= 8 || height <= 8)) {
-            return;
-        }
-        if (ratio === 1 && texture.getInternalTexture().url !== url) {
-            texture.updateURL(url);
-        }
-        else if (ratio < 1) {
-            const newUrl = `${dirname}/${split[0]}_${width}_${height}.${split[1]}`;
-            texture.updateURL(newUrl);
-        }
-        texture.metadata.editor.ratio = ratio;
-    });
-}
+    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);
+};
 //# sourceMappingURL=texture.js.map

package/build/tools/scalar.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPowerOfTwoUntil = void 0;
+function getPowerOfTwoUntil(limit) {
+    let size = 1;
+    while (size <= limit) {
+        size <<= 1;
+    }
+    return size >> 1;
+}
+exports.getPowerOfTwoUntil = getPowerOfTwoUntil;
+//# sourceMappingURL=scalar.js.map

package/declaration/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./loader";
-export * from "./texture";
 export * from "./rendering/ssao";
 export * from "./rendering/ssr";
 export * from "./rendering/motion-blur";

package/declaration/light.d.ts

@@ -0,0 +1,3 @@
+import { Scene } from "@babylonjs/core/scene";
+export declare function configureShadowMapRenderListPredicate(scene: Scene): void;
+export declare function configureShadowMapRefreshRate(scene: Scene): Promise<void>;

package/declaration/loader.d.ts

@@ -1,9 +1,31 @@
 import { Scene } from "@babylonjs/core/scene";
+import "./texture";
+/**
+ * Defines the possible output type of a script.
+ * `default` is a class that will be instantiated with the object as parameter.
+ * `onStart` is a function that will be called once before the first render passing the reference to the object the script is attached to.
+ * `onUpdate` is a function that will be called every frame passing the reference to the object the script is attached to
+ */
 export type ScriptMap = Record<string, {
     default?: new (object: any) => {
         onStart?(): void;
         onUpdate?(): void;
     };
+    onStart?: (object: any) => void;
+    onUpdate?: (object: any) => void;
 }>;
-export declare function loadScene(rootUrl: string, sceneFilename: string, scene: Scene, scriptsMap: ScriptMap): Promise<void>;
+/**
+ * Defines the overall desired quality of the scene.
+ * In other words, defines the quality of textures that will be loaded in terms of dimensions.
+ * The editor computes automatic "hight (untouched)", "medium (half)", and "low (quarter)" quality levels for textures.
+ * Using "medium" or "low" quality levels will reduce the memory usage and improve the performance of the scene
+ * especially on mobiles where memory is limited.
+ */
+export type SceneLoaderQualitySelector = "low" | "medium" | "high";
+declare module "@babylonjs/core/scene" {
+    interface Scene {
+        loadingQuality: SceneLoaderQualitySelector;
+    }
+}
+export declare function loadScene(rootUrl: string, sceneFilename: string, scene: Scene, scriptsMap: ScriptMap, quality?: SceneLoaderQualitySelector): Promise<void>;
 export declare function loadScriptsFor(scene: Scene, object: any, scriptsMap: ScriptMap): void;

package/declaration/texture.d.ts

@@ -1,2 +1 @@
-import { Scene } from "@babylonjs/core/scene";
-export declare function startTextureOptimizer(scene: Scene): void;
+export {};

package/declaration/tools/scalar.d.ts

@@ -0,0 +1 @@
+export declare function getPowerOfTwoUntil(limit: number): number;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "babylonjs-editor-tools",
-    "version": "0.0.3",
+    "version": "0.0.5",
     "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": {

package/build/rendering/default.js

@@ -1,98 +0,0 @@
-"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/declaration/rendering/default.d.ts

@@ -1,11 +0,0 @@
-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;