babylonjs-editor-tools 0.0.5 → 0.0.7

package/build/decorators/apply.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDecorators = void 0;
+function applyDecorators(scene, object, instance) {
+    const ctor = instance.constructor;
+    if (!ctor) {
+        return;
+    }
+    // @nodeFromScene
+    ctor._NodesFromScene?.forEach((params) => {
+        instance[params.propertyKey.toString()] = scene.getNodeByName(params.nodeName);
+    });
+    // @nodeFromDescendants
+    ctor._NodesFromDescendants?.forEach((params) => {
+        const descendant = object.getDescendants?.(params.directDescendantsOnly, (node) => node.name === params.nodeName)[0];
+        instance[params.propertyKey.toString()] = descendant ?? null;
+    });
+}
+exports.applyDecorators = applyDecorators;
+//# sourceMappingURL=apply.js.map

package/build/decorators/scene.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeFromDescendants = exports.nodeFromScene = void 0;
+/**
+ * Makes the decorated property linked to the node that has the given name.
+ * Once the script is instantiated, the reference to the node is retrieved from the scene
+ * and assigned to the property. Node link cant' be used in constructor.
+ * This can be used only by scripts using Classes.
+ * @param nodeName defines the name of the node to retrieve in scene.
+ */
+function nodeFromScene(nodeName) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        ctor._NodesFromScene ??= [];
+        ctor._NodesFromScene.push({ propertyKey, nodeName });
+    };
+}
+exports.nodeFromScene = nodeFromScene;
+/**
+ * Makes the decorated property linked to the node that has the given name.
+ * Once the script is instantiated, the reference to the node is retrieved from the descendants
+ * of the current node and assigned to the property. Node link cant' be used in constructor.
+ * This can be used only by scripts using Classes.
+ * @param nodeName defines the name of the node to retrieve in scene.
+ * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered.
+ */
+function nodeFromDescendants(nodeName, directDescendantsOnly = false) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        ctor._NodesFromDescendants ??= [];
+        ctor._NodesFromDescendants.push({ propertyKey, nodeName, directDescendantsOnly });
+    };
+}
+exports.nodeFromDescendants = nodeFromDescendants;
+//# sourceMappingURL=scene.js.map

package/build/index.js

@@ -19,4 +19,5 @@ __exportStar(require("./rendering/ssao"), exports);
 __exportStar(require("./rendering/ssr"), exports);
 __exportStar(require("./rendering/motion-blur"), exports);
 __exportStar(require("./rendering/default-pipeline"), exports);
+__exportStar(require("./decorators/scene"), exports);
 //# sourceMappingURL=index.js.map

package/build/loader.js

@@ -6,11 +6,12 @@ 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");
+const apply_1 = require("./decorators/apply");
 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);
+    await sceneLoader_1.SceneLoader.AppendAsync(rootUrl, sceneFilename, scene, null, ".babylon");
     (0, light_1.configureShadowMapRenderListPredicate)(scene);
     (0, light_1.configureShadowMapRefreshRate)(scene);
     if (scene.metadata?.rendering) {
@@ -49,6 +50,7 @@ function loadScriptsFor(scene, object, scriptsMap) {
         }
         if (exports.default) {
             const instance = new exports.default(object);
+            (0, apply_1.applyDecorators)(scene, object, instance);
             if (instance.onStart) {
                 scene.onBeforeRenderObservable.addOnce(() => instance.onStart());
             }

package/build/rendering/default-pipeline.js

@@ -62,37 +62,40 @@ function serializeDefaultRenderingPipeline() {
 }
 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;
+    if (defaultRenderingPipeline) {
+        return defaultRenderingPipeline;
     }
-    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;
+    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.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;
+    return pipeline;
 }
 exports.parseDefaultRenderingPipeline = parseDefaultRenderingPipeline;
 //# sourceMappingURL=default-pipeline.js.map

package/build/rendering/motion-blur.js

@@ -33,11 +33,14 @@ function serializeMotionBlurPostProcess() {
 }
 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;
+    if (motionBlurPostProcess) {
+        return motionBlurPostProcess;
+    }
+    const postProcess = createMotionBlurPostProcess(scene, camera);
+    postProcess.isObjectBased = data.isObjectBased;
+    postProcess.motionStrength = data.motionStrength;
+    postProcess.motionBlurSamples = data.motionBlurSamples;
+    return postProcess;
 }
 exports.parseMotionBlurPostProcess = parseMotionBlurPostProcess;
 //# sourceMappingURL=motion-blur.js.map

package/build/rendering/ssao.js

@@ -41,20 +41,23 @@ function serializeSSAO2RenderingPipeline() {
 }
 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;
+    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;
 }
 exports.parseSSAO2RenderingPipeline = parseSSAO2RenderingPipeline;
 //# sourceMappingURL=ssao.js.map

package/build/rendering/ssr.js

@@ -50,29 +50,32 @@ function serializeSSRRenderingPipeline() {
 }
 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;
+    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;
 }
 exports.parseSSRRenderingPipeline = parseSSRRenderingPipeline;
 //# sourceMappingURL=ssr.js.map

package/build/texture.js

@@ -12,16 +12,25 @@ decorators_serialization_1.SerializationHelper._TextureParser = (sourceProperty,
     }
     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);
     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);
+            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);
+            }
             suffix = `_${midWidth}_${midHeight}`;
             break;
         case "low":
-            const lowWidth = (0, scalar_1.getPowerOfTwoUntil)(width * 0.33);
-            const lowHeight = (0, scalar_1.getPowerOfTwoUntil)(height * 0.33);
+            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);
+            }
             suffix = `_${lowWidth}_${lowHeight}`;
             break;
     }

package/declaration/decorators/apply.d.ts

@@ -0,0 +1,13 @@
+import { Scene } from "@babylonjs/core/scene";
+export interface ISceneDecoratorData {
+    _NodesFromScene: {
+        nodeName: string;
+        propertyKey: string | Symbol;
+    }[];
+    _NodesFromDescendants: {
+        nodeName: string;
+        propertyKey: string | Symbol;
+        directDescendantsOnly: boolean;
+    }[];
+}
+export declare function applyDecorators(scene: Scene, object: any, instance: any): void;

package/declaration/decorators/scene.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Makes the decorated property linked to the node that has the given name.
+ * Once the script is instantiated, the reference to the node is retrieved from the scene
+ * and assigned to the property. Node link cant' be used in constructor.
+ * This can be used only by scripts using Classes.
+ * @param nodeName defines the name of the node to retrieve in scene.
+ */
+export declare function nodeFromScene(nodeName: string): (target: any, propertyKey: string | Symbol) => void;
+/**
+ * Makes the decorated property linked to the node that has the given name.
+ * Once the script is instantiated, the reference to the node is retrieved from the descendants
+ * of the current node and assigned to the property. Node link cant' be used in constructor.
+ * This can be used only by scripts using Classes.
+ * @param nodeName defines the name of the node to retrieve in scene.
+ * @param directDescendantsOnly defines if true only direct descendants of 'this' will be considered, if false direct and also indirect (children of children, an so on in a recursive manner) descendants of 'this' will be considered.
+ */
+export declare function nodeFromDescendants(nodeName: string, directDescendantsOnly?: boolean): (target: any, propertyKey: string | Symbol) => void;

package/declaration/index.d.ts

@@ -3,3 +3,4 @@ export * from "./rendering/ssao";
 export * from "./rendering/ssr";
 export * from "./rendering/motion-blur";
 export * from "./rendering/default-pipeline";
+export * from "./decorators/scene";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "babylonjs-editor-tools",
-    "version": "0.0.5",
+    "version": "0.0.7",
     "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": {
@@ -10,7 +10,7 @@
     "typings": "declaration/index.ts",
     "license": "(Apache-2.0)",
     "devDependencies": {
-        "@babylonjs/core": "7.0.0",
+        "@babylonjs/core": "7.15.1",
         "typescript": "5.3.3"
     },
     "dependencies": {}