babylonjs-editor-tools 0.0.1

package/build/guards.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTexture = exports.isMesh = void 0;
+/**
+ * Returns wether or not the given object is a Mesh.
+ * @param object defines the reference to the object to test its class name.
+ */
+function isMesh(object) {
+    return object.getClassName?.() === "Mesh";
+}
+exports.isMesh = isMesh;
+/**
+ * Returns wether or not the given object is a Texture.
+ * @param object defines the reference to the object to test its class name.
+ */
+function isTexture(object) {
+    return object?.getClassName?.() === "Texture";
+}
+exports.isTexture = isTexture;
+//# sourceMappingURL=guards.js.map

package/build/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./loader"), exports);
+__exportStar(require("./texture"), exports);
+//# sourceMappingURL=index.js.map

package/build/loader.js

@@ -0,0 +1,40 @@
+"use strict";
+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) {
+    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));
+}
+exports.loadScene = loadScene;
+function loadScriptsFor(scene, object) {
+    if (!object.metadata) {
+        return;
+    }
+    const map = require("@/scripts").scriptsMap;
+    object.metadata.scripts?.forEach((script) => {
+        if (!script.enabled) {
+            return;
+        }
+        const exports = map[script.key];
+        if (!exports) {
+            return;
+        }
+        if (exports.default) {
+            const instance = new exports.default(object);
+            scene.onBeforeRenderObservable.addOnce(() => {
+                instance.onStart?.();
+            });
+            if (instance.onUpdate) {
+                scene.onBeforeRenderObservable.add(() => instance.onUpdate());
+            }
+        }
+    });
+    object.metadata.scripts = undefined;
+}
+exports.loadScriptsFor = loadScriptsFor;
+//# sourceMappingURL=loader.js.map

package/build/texture.js

@@ -0,0 +1,81 @@
+"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);
+    }
+    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;
+    }
+    let isInFrustrum = false;
+    if (mesh.instances.length) {
+        isInFrustrum = [mesh, ...mesh.instances].find((instance) => camera.isInFrustum(instance)) ? true : false;
+    }
+    else {
+        isInFrustrum = camera.isInFrustum(mesh);
+    }
+    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;
+    });
+}
+//# sourceMappingURL=texture.js.map

package/declaration/guards.d.ts

@@ -0,0 +1,12 @@
+import { Mesh } from "@babylonjs/core/Meshes/mesh";
+import { Texture } from "@babylonjs/core/Materials/Textures/texture";
+/**
+ * Returns wether or not the given object is a Mesh.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isMesh(object: any): object is Mesh;
+/**
+ * Returns wether or not the given object is a Texture.
+ * @param object defines the reference to the object to test its class name.
+ */
+export declare function isTexture(object: any): object is Texture;

package/declaration/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./loader";
+export * from "./texture";

package/declaration/loader.d.ts

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

package/declaration/texture.d.ts

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

package/package.json

@@ -0,0 +1,17 @@
+{
+    "name": "babylonjs-editor-tools",
+    "version": "0.0.1",
+    "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": {
+        "watch": "tsc -p . --watch"
+    },
+    "main": "build/index.js",
+    "typings": "declaration/index.ts",
+    "license": "(Apache-2.0)",
+    "devDependencies": {
+        "@babylonjs/core": "7.0.0",
+        "typescript": "5.3.3"
+    },
+    "dependencies": {}
+}