babylonjs-editor-tools 0.0.8 → 0.0.9

package/build/src/cinematic/events/apply-impulse.js

@@ -0,0 +1,12 @@
+import { Vector3 } from "@babylonjs/core/Maths/math.vector";
+export function handleApplyImpulseEvent(scene, config) {
+    const meshes = config.mesh
+        ? [scene.getNodeById(config.mesh)]
+        : scene.meshes;
+    meshes.forEach((mesh) => {
+        if (mesh.physicsAggregate?.body) {
+            mesh.physicsAggregate.body.applyImpulse(Vector3.FromArray(config.force), Vector3.FromArray(config.contactPoint));
+        }
+    });
+}
+//# sourceMappingURL=apply-impulse.js.map

package/build/src/cinematic/events/set-enabled.js

@@ -0,0 +1,5 @@
+export function handleSetEnabledEvent(scene, config) {
+    const node = scene.getNodeById(config.node);
+    node?.setEnabled(config.value);
+}
+//# sourceMappingURL=set-enabled.js.map

package/build/src/cinematic/generate.js

@@ -0,0 +1,134 @@
+import { Tools } from "@babylonjs/core/Misc/tools";
+import { Animation } from "@babylonjs/core/Animations/animation";
+import { AnimationEvent } from "@babylonjs/core/Animations/animationEvent";
+import { AnimationGroup } from "@babylonjs/core/Animations/animationGroup";
+import { getDefaultRenderingPipeline } from "../rendering/default-pipeline";
+import { handleSetEnabledEvent } from "./events/set-enabled";
+import { handleApplyImpulseEvent } from "./events/apply-impulse";
+import { cloneKey, getAnimationTypeForObject, getPropertyValue } from "./tools";
+/**
+ * Parses the given cinematic object and generates a new playable animation group.
+ * @param cinematic defines the cinematic object to parse that was previously loaded.
+ * @param scene defines the reference to the scene where to retrieve the animated objects.
+ */
+export function generateCinematicAnimationGroup(cinematic, scene) {
+    const result = new AnimationGroup(cinematic.name, scene);
+    cinematic.tracks.forEach((track) => {
+        // Animation groups
+        const animationGroup = track.animationGroup;
+        if (animationGroup) {
+            track.animationGroups?.forEach((configuration) => {
+                animationGroup.targetedAnimations.forEach((targetedAnimation) => {
+                    let animation = null;
+                    defer: {
+                        const existingTargetedAnimations = result.targetedAnimations.filter((ta2) => ta2.target === targetedAnimation.target);
+                        if (existingTargetedAnimations.length) {
+                            const existingTargetedAnimationsPair = existingTargetedAnimations.find((et) => et.animation.targetProperty === targetedAnimation.animation.targetProperty);
+                            if (existingTargetedAnimationsPair) {
+                                animation = existingTargetedAnimationsPair.animation;
+                                break defer;
+                            }
+                        }
+                        animation = targetedAnimation.animation.clone();
+                        animation.setKeys([]);
+                        animation.name = Tools.RandomId();
+                        animation.framePerSecond = cinematic.framesPerSecond;
+                    }
+                    const keys = animation.getKeys();
+                    const sourceKeys = targetedAnimation.animation.getKeys();
+                    const speed = configuration.speed;
+                    const normalizedFps = (cinematic.framesPerSecond / targetedAnimation.animation.framePerSecond) / speed;
+                    sourceKeys.forEach((k) => {
+                        if (k.frame >= configuration.startFrame && k.frame <= configuration.endFrame) {
+                            keys.push({
+                                ...cloneKey(targetedAnimation.animation.dataType, k),
+                                frame: configuration.frame + k.frame * normalizedFps,
+                            });
+                        }
+                    });
+                    animation.setKeys(keys);
+                    result.addTargetedAnimation(animation, targetedAnimation.target);
+                });
+            });
+        }
+        const sound = track.sound;
+        const soundBuffer = sound?.getAudioBuffer();
+        if (sound && soundBuffer && track.sounds?.length) {
+            const dummyObject = {
+                dummy: 0,
+            };
+            const soundAnimation = new Animation(sound.name, "dummy", 60, Animation.ANIMATIONTYPE_FLOAT, Animation.ANIMATIONLOOPMODE_CYCLE, false);
+            let maxFrame = 0;
+            track.sounds?.forEach((configuration) => {
+                const duration = configuration.endFrame - configuration.startFrame;
+                maxFrame = Math.max(maxFrame, configuration.frame + duration);
+                soundAnimation.addEvent(new AnimationEvent(configuration.frame, (currentFrame) => {
+                    const frameDiff = currentFrame - configuration.frame;
+                    const offset = (frameDiff + configuration.startFrame) / cinematic.framesPerSecond;
+                    // sound.stop();
+                    sound.play(0, offset);
+                }, false));
+                soundAnimation.addEvent(new AnimationEvent(configuration.frame + duration, () => {
+                    sound.stop();
+                }));
+            });
+            soundAnimation.setKeys([
+                { frame: 0, value: 0 },
+                { frame: maxFrame, value: maxFrame },
+            ]);
+            result.addTargetedAnimation(soundAnimation, dummyObject);
+        }
+        if (track.keyFrameEvents) {
+            const dummyObject = {
+                dummy: 0,
+            };
+            const eventsAnimation = new Animation("events", "dummy", 60, Animation.ANIMATIONTYPE_FLOAT, Animation.ANIMATIONLOOPMODE_CYCLE, false);
+            let maxFrame = 0;
+            track.keyFrameEvents?.forEach((configuration) => {
+                maxFrame = Math.max(maxFrame, configuration.frame);
+                eventsAnimation.addEvent(new AnimationEvent(configuration.frame, () => {
+                    switch (configuration.data?.type) {
+                        case "set-enabled":
+                            handleSetEnabledEvent(scene, configuration.data);
+                            break;
+                        case "apply-impulse":
+                            handleApplyImpulseEvent(scene, configuration.data);
+                            break;
+                    }
+                }));
+            });
+            eventsAnimation.setKeys([
+                { frame: 0, value: 0 },
+                { frame: maxFrame, value: maxFrame },
+            ]);
+            result.addTargetedAnimation(eventsAnimation, dummyObject);
+        }
+        const node = track.defaultRenderingPipeline ? getDefaultRenderingPipeline() : track.node;
+        if (!node || !track.propertyPath || !track.keyFrameAnimations) {
+            return;
+        }
+        const value = getPropertyValue(node, track.propertyPath);
+        const animationType = getAnimationTypeForObject(value);
+        if (animationType === null) {
+            return;
+        }
+        const animation = new Animation(track.propertyPath, track.propertyPath, 60, animationType, Animation.ANIMATIONLOOPMODE_CYCLE, false);
+        const keys = [];
+        track.keyFrameAnimations?.forEach((keyFrame) => {
+            const animationKey = keyFrame.type === "key" ? keyFrame : null;
+            if (animationKey) {
+                return keys.push(animationKey);
+            }
+            const animationKeyCut = keyFrame.type === "cut" ? keyFrame : null;
+            if (animationKeyCut) {
+                keys.push(animationKeyCut.key1);
+                keys.push(animationKeyCut.key2);
+            }
+        });
+        animation.setKeys(keys);
+        result.addTargetedAnimation(animation, node);
+    });
+    result.normalize();
+    return result;
+}
+//# sourceMappingURL=generate.js.map

package/build/src/cinematic/parse.js

@@ -0,0 +1,99 @@
+import { Animation } from "@babylonjs/core/Animations/animation";
+import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
+import { Quaternion, Vector2, Vector3, Matrix } from "@babylonjs/core/Maths/math.vector";
+import { getDefaultRenderingPipeline } from "../rendering/default-pipeline";
+import { getSoundById } from "../tools/sound";
+import { getAnimationTypeForObject, getPropertyValue } from "./tools";
+/**
+ * Parses the given JSON data and returns a new cinematic object.
+ * @param data defines the JSON data of the cinematic to parse.
+ * @param scene defines the reference to the scene used to retrieve cinematic's data.
+ */
+export function parseCinematic(data, scene) {
+    return {
+        name: data.name,
+        framesPerSecond: data.framesPerSecond,
+        outputFramesPerSecond: data.outputFramesPerSecond,
+        tracks: data.tracks.map((track) => {
+            let node = null;
+            let animationType = null;
+            if (track.node) {
+                node = scene.getNodeById(track.node);
+            }
+            else if (track.defaultRenderingPipeline) {
+                node = getDefaultRenderingPipeline();
+            }
+            if (track.propertyPath) {
+                const value = getPropertyValue(node, track.propertyPath);
+                animationType = getAnimationTypeForObject(value);
+            }
+            let sound = null;
+            if (track.sound) {
+                sound = getSoundById(track.sound, scene);
+            }
+            return {
+                node,
+                sound,
+                propertyPath: track.propertyPath,
+                defaultRenderingPipeline: track.defaultRenderingPipeline,
+                animationGroup: track.animationGroup ? scene.getAnimationGroupByName(track.animationGroup) : null,
+                animationGroups: track.animationGroups,
+                sounds: track.sounds,
+                keyFrameEvents: track.keyFrameEvents,
+                keyFrameAnimations: node && animationType !== null && track.keyFrameAnimations?.map((keyFrame) => {
+                    const animationKey = keyFrame.type === "key" ? keyFrame : null;
+                    if (animationKey) {
+                        return {
+                            ...animationKey,
+                            value: parseCinematicKeyValue(animationKey.value, animationType),
+                            inTangent: parseCinematicKeyValue(animationKey.inTangent, animationType),
+                            outTangent: parseCinematicKeyValue(animationKey.outTangent, animationType),
+                        };
+                    }
+                    const animationKeyCut = keyFrame.type === "cut" ? keyFrame : null;
+                    if (animationKeyCut) {
+                        return {
+                            ...animationKeyCut,
+                            key1: {
+                                ...animationKeyCut.key1,
+                                value: parseCinematicKeyValue(animationKeyCut.key1.value, animationType),
+                                inTangent: parseCinematicKeyValue(animationKeyCut.key1.inTangent, animationType),
+                                outTangent: parseCinematicKeyValue(animationKeyCut.key1.outTangent, animationType),
+                            },
+                            key2: {
+                                ...animationKeyCut.key2,
+                                value: parseCinematicKeyValue(animationKeyCut.key2.value, animationType),
+                                inTangent: parseCinematicKeyValue(animationKeyCut.key2.inTangent, animationType),
+                                outTangent: parseCinematicKeyValue(animationKeyCut.key2.outTangent, animationType),
+                            },
+                        };
+                    }
+                }),
+            };
+        }),
+    };
+}
+/**
+ * Parses the given value and returns the reference to the right value to be animated.
+ * @param value defines the raw value to parse (ie. number or array for vectors).
+ * @param type defines the type of the property animated.
+ * @example [0, 0, 0] with type Animation.ANIMATIONTYPE_VECTOR3 will return a new Vector3(0, 0, 0) object.
+ */
+export function parseCinematicKeyValue(value, type) {
+    if (value === null) {
+        return null;
+    }
+    if (value === undefined) {
+        return undefined;
+    }
+    switch (type) {
+        case Animation.ANIMATIONTYPE_FLOAT: return value;
+        case Animation.ANIMATIONTYPE_VECTOR2: return Vector2.FromArray(value);
+        case Animation.ANIMATIONTYPE_VECTOR3: return Vector3.FromArray(value);
+        case Animation.ANIMATIONTYPE_QUATERNION: return Quaternion.FromArray(value);
+        case Animation.ANIMATIONTYPE_COLOR3: return Color3.FromArray(value);
+        case Animation.ANIMATIONTYPE_COLOR4: return Color4.FromArray(value);
+        case Animation.ANIMATIONTYPE_MATRIX: return Matrix.FromArray(value);
+    }
+}
+//# sourceMappingURL=parse.js.map

package/build/src/cinematic/tools.js

@@ -0,0 +1,66 @@
+import { Size } from "@babylonjs/core/Maths/math.size";
+import { Animation } from "@babylonjs/core/Animations/animation";
+import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
+import { Quaternion, Vector2, Vector3 } from "@babylonjs/core/Maths/math.vector";
+export function cloneKey(dataType, key) {
+    let value;
+    switch (dataType) {
+        case Animation.ANIMATIONTYPE_FLOAT:
+            value = key.value;
+            break;
+        default:
+            value = key.value.clone();
+            break;
+    }
+    return {
+        value,
+        frame: key.frame,
+        interpolation: key.interpolation,
+        inTangent: dataType === Animation.ANIMATIONTYPE_FLOAT ? key.inTangent : key.inTangent?.clone(),
+        outTangent: dataType === Animation.ANIMATIONTYPE_FLOAT ? key.outTangent : key.outTangent?.clone(),
+    };
+}
+/**
+ * Returns the animation type according to the given animated property type.
+ * @param effectiveProperty defines the reference to the animated property to get its animation type.
+ */
+export function getAnimationTypeForObject(effectiveProperty) {
+    if (!isNaN(parseFloat(effectiveProperty)) && isFinite(effectiveProperty)) {
+        return Animation.ANIMATIONTYPE_FLOAT;
+    }
+    else if (effectiveProperty instanceof Quaternion) {
+        return Animation.ANIMATIONTYPE_QUATERNION;
+    }
+    else if (effectiveProperty instanceof Vector3) {
+        return Animation.ANIMATIONTYPE_VECTOR3;
+    }
+    else if (effectiveProperty instanceof Vector2) {
+        return Animation.ANIMATIONTYPE_VECTOR2;
+    }
+    else if (effectiveProperty instanceof Color3) {
+        return Animation.ANIMATIONTYPE_COLOR3;
+    }
+    else if (effectiveProperty instanceof Color4) {
+        return Animation.ANIMATIONTYPE_COLOR4;
+    }
+    else if (effectiveProperty instanceof Size) {
+        return Animation.ANIMATIONTYPE_SIZE;
+    }
+    return null;
+}
+/**
+ * Returns the current value of the given property of the given object.
+ * @param object defines the root object where to parse the property and return its value.
+ * @param property defines the path of the property to get its value.
+ * @example getPropertyValue(scene, "ambientColor");
+ * @example getPropertyValue(scene, "ambientColor.r");
+ */
+export function getPropertyValue(object, property) {
+    const parts = property.split('.');
+    let value = object;
+    for (let i = 0; i < parts.length; ++i) {
+        value = value[parts[i]];
+    }
+    return value;
+}
+//# sourceMappingURL=tools.js.map

package/build/src/cinematic/typings.js

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

package/build/src/decorators/apply.js

@@ -0,0 +1,71 @@
+import { Vector2, Vector3 } from "@babylonjs/core/Maths/math.vector";
+import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
+export function applyDecorators(scene, object, script, instance, rootUrl) {
+    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;
+    });
+    // @fromAnimationGroups
+    ctor._AnimationGroups?.forEach((params) => {
+        instance[params.propertyKey.toString()] = scene.getAnimationGroupByName(params.animationGroupName);
+    });
+    // @soundFromScene
+    ctor._SoundsFromScene?.forEach((params) => {
+        const sound = scene.getSoundByName?.(params.soundName);
+        instance[params.propertyKey.toString()] = sound ?? null;
+    });
+    // @guiFromAsset
+    ctor._GuiFromAsset?.forEach(async (params) => {
+        const guiUrl = `${rootUrl}assets/${params.pathInAssets}`;
+        try {
+            const response = await fetch(guiUrl);
+            const data = await response.json();
+            const gui = AdvancedDynamicTexture.CreateFullscreenUI(data.name, true, scene);
+            gui.parseSerializedObject(data.content, false);
+            instance[params.propertyKey.toString()] = gui;
+            params.onGuiCreated?.(instance, gui);
+        }
+        catch (e) {
+            console.error(`Failed to load GUI from asset: ${guiUrl}`);
+            throw e;
+        }
+    });
+    // @fromParticleSystems
+    ctor._ParticleSystemsFromScene?.forEach((params) => {
+        const particleSystem = scene.particleSystems?.find((particleSystem) => {
+            return particleSystem.name === params.particleSystemName;
+        });
+        instance[params.propertyKey.toString()] = particleSystem;
+    });
+    // @visibleAsNumber, @visibleAsBoolean etc.
+    ctor._VisibleInInspector?.forEach((params) => {
+        const propertyKey = params.propertyKey.toString();
+        const attachedScripts = script.values;
+        if (attachedScripts.hasOwnProperty(propertyKey) &&
+            attachedScripts[propertyKey].hasOwnProperty("value")) {
+            const value = attachedScripts[propertyKey].value;
+            switch (params.configuration.type) {
+                case "number":
+                case "boolean":
+                    instance[propertyKey] = value;
+                    break;
+                case "vector2":
+                    instance[propertyKey] = Vector2.FromArray(value);
+                    break;
+                case "vector3":
+                    instance[propertyKey] = Vector3.FromArray(value);
+                    break;
+            }
+        }
+    });
+}
+//# sourceMappingURL=apply.js.map

package/build/{decorators → src/decorators}/gui.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.guiFromAsset = void 0;
 /**
  * Makes the decorated property linked to the GUI created from the given asset file.
  * Once the script is instantiated, the reference to the gui texture is created from the asset file
@@ -11,12 +8,11 @@ exports.guiFromAsset = void 0;
  *  @guiFromAsset<MyScriptClass>("ui.gui", (instance, gui) => instance._onGuiLoaded(gui))
  *  private _ui!: AdvancedDynamicTexture;
  */
-function guiFromAsset(pathInAssets, onGuiCreated) {
+export function guiFromAsset(pathInAssets, onGuiCreated) {
     return function (target, propertyKey) {
         const ctor = target.constructor;
         ctor._GuiFromAsset ??= [];
         ctor._GuiFromAsset.push({ propertyKey, pathInAssets, onGuiCreated });
     };
 }
-exports.guiFromAsset = guiFromAsset;
 //# sourceMappingURL=gui.js.map

package/build/src/decorators/inspector.js

@@ -0,0 +1,131 @@
+/**
+ * Makes the decorated property visible in the editor inspector as a boolean.
+ * The property can be customized per object in the editor and the custom value is applied
+ * once the script is invoked at runtime in the game/application.
+ * This can be used only by scripts using Classes.
+ * @param label defines the optional label displayed in the inspector in the editor.
+ */
+export function visibleAsBoolean(label) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        ctor._VisibleInInspector ??= [];
+        ctor._VisibleInInspector.push({
+            label,
+            propertyKey,
+            configuration: {
+                type: "boolean",
+            },
+        });
+    };
+}
+/**
+ * Makes the decorated property visible in the editor inspector as a number.
+ * The property can be customized per object in the editor and the custom value is applied
+ * once the script is invoked at runtime in the game/application.
+ * This can be used only by scripts using Classes.
+ * @param label defines the optional label displayed in the inspector in the editor.
+ * @param configuration defines the optional configuration for the field in the inspector (min, max, etc.).
+ */
+export function visibleAsNumber(label, configuration) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        ctor._VisibleInInspector ??= [];
+        ctor._VisibleInInspector.push({
+            label,
+            propertyKey,
+            configuration: {
+                ...configuration,
+                type: "number",
+            },
+        });
+    };
+}
+/**
+ * Makes the decorated property visible in the editor inspector as a vector2.
+ * The property can be customized per object in the editor and the custom value is applied
+ * once the script is invoked at runtime in the game/application.
+ * This can be used only by scripts using Classes.
+ * @param label defines the optional label displayed in the inspector in the editor.
+ * @param configuration defines the optional configuration for the field in the inspector (min, max, etc.).
+ */
+export function visibleAsVector2(label, configuration) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        ctor._VisibleInInspector ??= [];
+        ctor._VisibleInInspector.push({
+            label,
+            propertyKey,
+            configuration: {
+                ...configuration,
+                type: "vector2",
+            },
+        });
+    };
+}
+/**
+ * Makes the decorated property visible in the editor inspector as a vector3.
+ * The property can be customized per object in the editor and the custom value is applied
+ * once the script is invoked at runtime in the game/application.
+ * This can be used only by scripts using Classes.
+ * @param label defines the optional label displayed in the inspector in the editor.
+ * @param configuration defines the optional configuration for the field in the inspector (min, max, etc.).
+ */
+export function visibleAsVector3(label, configuration) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        ctor._VisibleInInspector ??= [];
+        ctor._VisibleInInspector.push({
+            label,
+            propertyKey,
+            configuration: {
+                ...configuration,
+                type: "vector3",
+            },
+        });
+    };
+}
+/**
+ * Makes the decorated property visible in the editor inspector as a color3.
+ * The property can be customized per object in the editor and the custom value is applied
+ * once the script is invoked at runtime in the game/application.
+ * This can be used only by scripts using Classes.
+ * @param label defines the optional label displayed in the inspector in the editor.
+ * @param configuration defines the optional configuration for the field in the inspector (min, max, etc.).
+ */
+export function visibleAsColor3(label, configuration) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        ctor._VisibleInInspector ??= [];
+        ctor._VisibleInInspector.push({
+            label,
+            propertyKey,
+            configuration: {
+                ...configuration,
+                type: "color3",
+            },
+        });
+    };
+}
+/**
+ * Makes the decorated property visible in the editor inspector as a color4.
+ * The property can be customized per object in the editor and the custom value is applied
+ * once the script is invoked at runtime in the game/application.
+ * This can be used only by scripts using Classes.
+ * @param label defines the optional label displayed in the inspector in the editor.
+ * @param configuration defines the optional configuration for the field in the inspector (min, max, etc.).
+ */
+export function visibleAsColor4(label, configuration) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        ctor._VisibleInInspector ??= [];
+        ctor._VisibleInInspector.push({
+            label,
+            propertyKey,
+            configuration: {
+                ...configuration,
+                type: "color4",
+            },
+        });
+    };
+}
+//# sourceMappingURL=inspector.js.map

package/build/src/decorators/particle-systems.js

@@ -0,0 +1,15 @@
+/**
+ * Makes the decorated property linked to the particle system that has the given name.
+ * Once the script is instantiated, the reference to the particle system 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 particleSystemName defines the name of the sound to retrieve in scene.
+ */
+export function particleSystemFromScene(particleSystemName) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        ctor._ParticleSystemsFromScene ??= [];
+        ctor._ParticleSystemsFromScene.push({ propertyKey, particleSystemName });
+    };
+}
+//# sourceMappingURL=particle-systems.js.map

package/build/{decorators → src/decorators}/scene.js

@@ -1,6 +1,3 @@
-"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
@@ -8,14 +5,13 @@ exports.nodeFromDescendants = exports.nodeFromScene = void 0;
  * This can be used only by scripts using Classes.
  * @param nodeName defines the name of the node to retrieve in scene.
  */
-function nodeFromScene(nodeName) {
+export 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
@@ -24,12 +20,25 @@ exports.nodeFromScene = nodeFromScene;
  * @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) {
+export function nodeFromDescendants(nodeName, directDescendantsOnly = false) {
     return function (target, propertyKey) {
         const ctor = target.constructor;
         ctor._NodesFromDescendants ??= [];
         ctor._NodesFromDescendants.push({ propertyKey, nodeName, directDescendantsOnly });
     };
 }
-exports.nodeFromDescendants = nodeFromDescendants;
+/**
+ * Makes the decorated property linked to an animation group that has the given name.
+ * Once the script is instantiated, the reference to the animation group is retrieved from the scene
+ * and assigned to the property. Animation group link cant' be used in constructor.
+ * This can be used only by scripts using Classes.
+ * @param animationGroupName defines the name of the animation group to retrieve in scene.
+ */
+export function animationGroupFromScene(animationGroupName) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        ctor._AnimationGroups ??= [];
+        ctor._AnimationGroups.push({ animationGroupName, propertyKey });
+    };
+}
 //# sourceMappingURL=scene.js.map

package/build/{decorators → src/decorators}/sound.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.soundFromScene = void 0;
 /**
  * Makes the decorated property linked to the sound that has the given name.
  * Once the script is instantiated, the reference to the sound is retrieved from the scene
@@ -8,12 +5,11 @@ exports.soundFromScene = void 0;
  * This can be used only by scripts using Classes.
  * @param soundName defines the name of the sound to retrieve in scene.
  */
-function soundFromScene(soundName) {
+export function soundFromScene(soundName) {
     return function (target, propertyKey) {
         const ctor = target.constructor;
         ctor._SoundsFromScene ??= [];
         ctor._SoundsFromScene.push({ propertyKey, soundName });
     };
 }
-exports.soundFromScene = soundFromScene;
 //# sourceMappingURL=sound.js.map

package/build/src/index.js

@@ -0,0 +1,17 @@
+export * from "./loading/loader";
+export * from "./tools/texture";
+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