@preference-sl/pref-viewer 2.11.0-beta.1 → 2.11.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@preference-sl/pref-viewer",
-  "version": "2.11.0-beta.1",
+  "version": "2.11.0-beta.3",
   "description": "Web Component to preview GLTF models with Babylon.js",
   "author": "Alex Moreno Palacio <amoreno@preference.es>",
   "scripts": {
@@ -30,15 +30,16 @@
   "sideEffects": false,
   "files": [
     "src",
-    "src/models",
+    "src/images",
     "index.d.ts"
   ],
   "dependencies": {
-    "@babylonjs/core": "^8.31.3",
-    "@babylonjs/loaders": "^8.31.3",
-    "@babylonjs/serializers": "^8.31.3",
+    "@babylonjs/core": "^8.36.1",
+    "@babylonjs/gui": "^8.36.1",
+    "@babylonjs/loaders": "^8.36.1",
+    "@babylonjs/serializers": "^8.36.1",
     "@panzoom/panzoom": "^4.6.0",
-    "babylonjs-gltf2interface": "^8.31.3",
+    "babylonjs-gltf2interface": "^8.36.1",
     "idb": "^8.0.3",
     "is-svg": "^6.1.0"
   },

package/src/babylonjs-animation-controller.js

@@ -0,0 +1,536 @@
+import { Color3, PointerEventTypes, HighlightLayer } from "@babylonjs/core";
+import { AdvancedDynamicTexture, StackPanel, Control, Button, Image } from "@babylonjs/gui";
+
+// https://doc.babylonjs.com/typedoc/classes/BABYLON.AnimationGroup
+class OpeningAnimationController {
+    static states = {
+        paused: 0,
+        closed: 1,
+        opened: 2,
+        opening: 3,
+        closing: 4,
+    };
+
+    #openAnimation = null;
+    #closeAnimation = null;
+
+    #nodes = [];
+    #state = OpeningAnimationController.states.closed;
+    #currentFrame = 0;
+    #startFrame = 0;
+    #endFrame = 0;
+    #speedRatio = 1.0;
+
+    #advancedDynamicTexture = null;
+    #menu = null;
+
+    constructor(name, openAnimationGroup, closeAnimationGroup) {
+        this.name = name;
+        this.#openAnimation = openAnimationGroup;
+        this.#closeAnimation = closeAnimationGroup;
+
+        this.#openAnimation.stop();
+        this.#openAnimation._loopAnimation = false;
+        this.#closeAnimation.stop();
+        this.#closeAnimation._loopAnimation = false;
+
+        this.#startFrame = this.#openAnimation.from;
+        this.#endFrame = this.#openAnimation.to;
+        this.#speedRatio = this.#openAnimation.speedRatio || 1.0;
+
+        this.#getNodesFromAnimationGroups();
+        this.#openAnimation.onAnimationGroupEndObservable.add(this.#onOpened.bind(this));
+        this.#closeAnimation.onAnimationGroupEndObservable.add(this.#onClosed.bind(this));
+    }
+
+    #getNodesFromAnimationGroups() {
+        [this.#openAnimation, this.#closeAnimation].forEach((animationGroup) => {
+            animationGroup._targetedAnimations.forEach((targetedAnimation) => {
+                if (!this.#nodes.includes(targetedAnimation.target.id)) {
+                    this.#nodes.push(targetedAnimation.target.id);
+                }
+            });
+        });
+    }
+
+    #onOpened() {
+        this.goToOpened();
+    }
+
+    #onClosed() {
+        this.goToClosed();
+    }
+
+    /**
+     * ---------------------------
+     * Public methods
+     * ---------------------------
+     */
+
+    isAnimationForNode(node) {
+        return this.#nodes.includes(node);
+    }
+
+    playOpen() {
+        if (this.#state === OpeningAnimationController.states.opening || this.#state === OpeningAnimationController.states.opened) {
+            return;
+        }
+        if (this.#state === OpeningAnimationController.states.closing) {
+            this.#currentFrame = this.#endFrame - this.#closeAnimation.getCurrentFrame();
+            this.#closeAnimation.pause();
+        }
+
+        if (this.#openAnimation._isStarted && this.#openAnimation._isPaused) {
+            this.#openAnimation.goToFrame(this.#currentFrame);
+            this.#openAnimation.restart();
+        } else {
+            this.#openAnimation.start(false, this.#speedRatio, this.#currentFrame, this.#endFrame, undefined);
+        }
+
+        this.#state = OpeningAnimationController.states.opening;
+        this.updateControls();
+    }
+
+    playClose() {
+        if (this.#state === OpeningAnimationController.states.closing || this.#state === OpeningAnimationController.states.closed) {
+            return;
+        }
+        if (this.#state === OpeningAnimationController.states.opening) {
+            this.#currentFrame = this.#openAnimation.getCurrentFrame();
+            this.#openAnimation.pause();
+        }
+
+        if (this.#closeAnimation._isStarted && this.#closeAnimation._isPaused) {
+            this.#closeAnimation.goToFrame(this.#endFrame - this.#currentFrame);
+            this.#closeAnimation.restart();
+        } else {
+            this.#closeAnimation.start(false, this.#speedRatio, this.#endFrame - this.#currentFrame, this.#endFrame, undefined);
+        }
+
+        this.#state = OpeningAnimationController.states.closing;
+        this.updateControls();
+    }
+
+    pause() {
+        if (this.#state === OpeningAnimationController.states.opening) {
+            this.#currentFrame = this.#openAnimation.getCurrentFrame();
+            this.#openAnimation.pause();
+        }
+        if (this.#state === OpeningAnimationController.states.closing) {
+            this.#currentFrame = this.#endFrame - this.#closeAnimation.getCurrentFrame();
+            this.#closeAnimation.pause();
+        }
+        this.#state = OpeningAnimationController.states.paused;
+        this.updateControls();
+    }
+
+    goToOpened() {
+        this.#currentFrame = this.#endFrame;
+
+        if (this.#openAnimation._isStarted) {
+            this.#openAnimation.start();
+        }
+        this.#openAnimation.pause();
+        this.#openAnimation.goToFrame(this.#endFrame);
+
+        if (!this.#closeAnimation._isStarted) {
+            this.#closeAnimation.start();
+        }
+        this.#closeAnimation.pause();
+        this.#closeAnimation.goToFrame(this.#startFrame);
+
+        this.#state = OpeningAnimationController.states.opened;
+        this.updateControls();
+    }
+
+    goToClosed() {
+        this.#currentFrame = this.#startFrame;
+        if (this.#openAnimation._isStarted) {
+            this.#openAnimation.start();
+        }
+        this.#openAnimation.pause();
+        this.#openAnimation.goToFrame(this.#startFrame);
+
+        if (this.#closeAnimation._isStarted) {
+            this.#closeAnimation.start();
+        }
+        this.#closeAnimation.pause();
+        this.#closeAnimation.goToFrame(this.#endFrame);
+
+        this.#state = OpeningAnimationController.states.closed;
+        this.updateControls();
+    }
+
+    showControls(advancedDynamicTexture, mesh) {
+        this.#advancedDynamicTexture = advancedDynamicTexture;
+        this.#advancedDynamicTexture.metadata = { name: this.name };
+        const controlCallbacks = {
+            onGoToOpened: () => {
+                if (this.#state === OpeningAnimationController.states.opened) {
+                    return;
+                }
+                this.goToOpened();
+                this.hideControls();
+            },
+            onOpen: () => {
+                if (this.#state === OpeningAnimationController.states.opened || this.#state === OpeningAnimationController.states.opening) {
+                    return;
+                }
+                this.playOpen();
+                this.hideControls();
+            },
+            onPause: () => {
+                if (this.#state === OpeningAnimationController.states.paused || this.#state === OpeningAnimationController.states.closed || this.#state === OpeningAnimationController.states.opened) {
+                    return;
+                }
+                this.pause();
+                this.hideControls();
+            },
+            onClose: () => {
+                if (this.#state === OpeningAnimationController.states.closed || this.#state === OpeningAnimationController.states.closing) {
+                    return;
+                }
+                this.playClose();
+                this.hideControls();
+            },
+            onGoToClosed: () => {
+                if (this.#state === OpeningAnimationController.states.closed) {
+                    return;
+                }
+                this.goToClosed();
+                this.hideControls();
+            },
+        };
+        this.#menu = new AnimationMenu(this.#advancedDynamicTexture, mesh, this.#state, controlCallbacks);
+    }
+
+    hideControls() {
+        if (!this.isControlsVisible()) {
+            return;
+        }
+        this.#advancedDynamicTexture.dispose();
+        this.#advancedDynamicTexture = null;
+    }
+
+    updateControls() {
+        if (!this.isControlsVisible()) {
+            return;
+        }
+        if (!this.#menu) {
+            return;
+        }
+        this.#menu.animationState = this.#state;
+    }
+
+    isControlsVisible() {
+        return this.#advancedDynamicTexture !== null || this.#advancedDynamicTexture?.metadata?.name === this.name;
+    }
+
+    /**
+     * ---------------------------
+     * Public properties
+     * ---------------------------
+     */
+
+    get state() {
+        return this.#state;
+    }
+}
+
+/**
+ * AnimationMenu - Models and renders a popup menu for controlling animation playback in a Babylon.js 3D scene.
+ *
+ * Responsibilities:
+ *  - Creates a Babylon.js GUI panel with buttons for animation actions (open, close, pause, go to opened/closed).
+ *  - Handles button states (enabled/disabled, active/inactive) based on animation state.
+ *  - Attaches the menu to a mesh and disposes it when an action is taken.
+ *  - Allows external callbacks for each action.
+ *
+ * Usage:
+ *  const menu = new AnimationMenu(advancedDynamicTexture, mesh, animationState, {
+ *      onOpen: () => { ... },
+ *      onClose: () => { ... },
+ *      onPause: () => { ... },
+ *      onGoToOpened: () => { ... },
+ *      onGoToClosed: () => { ... }
+ *  });
+ *  menu.show();
+ *  menu.hide();
+ */
+
+class AnimationMenu {
+    #advancedDynamicTexture = null;
+    #animationState = OpeningAnimationController.states.closed;
+    #mesh = null;
+    #callbacks = null;
+    #panel = null;
+    #colorActive = "#6BA53A";
+    #colorEnabled = "#333333";
+    #colorDisabled = "#777777";
+
+    /**
+     * @param {AdvancedDynamicTexture} advancedDynamicTexture - Babylon.js GUI texture.
+     * @param {BABYLON.Mesh} mesh - Mesh to attach the menu to.
+     * @param {number} animationState - Current animation state (enum).
+     * @param {object} callbacks - Callback functions for menu actions.
+     */
+    constructor(advancedDynamicTexture, mesh, animationState, callbacks) {
+        this.#advancedDynamicTexture = advancedDynamicTexture;
+        this.#mesh = mesh;
+        this.#animationState = animationState;
+        this.#callbacks = callbacks;
+
+        this.#createMenu(animationState);
+    }
+
+    /**
+     * Renders the menu and attaches it to the mesh.
+     */
+    #createMenu() {
+        if (!this.#advancedDynamicTexture || !this.#mesh) {
+            return;
+        }
+        this.#panel = new StackPanel();
+        this.#panel.isVertical = false;
+        this.#panel.verticalAlignment = Control.VERTICAL_ALIGNMENT_BOTTOM;
+        this.#panel.left = 0;
+        this.#panel.top = 0;
+        this.#advancedDynamicTexture.addControl(this.#panel);
+        this.#panel.linkWithMesh(this.#mesh);
+
+        this.#createButtons();
+        this.#setButtonsState();
+    }
+
+    /**
+     * Internal helper to add a button to the menu.
+     * @private
+     */
+    #addButton(name, imageURL, callback) {
+        const button = Button.CreateImageOnlyButton(`button_animation_${name}`, imageURL);
+        button.image.stretch = Image.STRETCH_UNIFORM;
+        button.color = "white";
+        button.hoverCursor = "pointer";
+        button.width = "28px";
+        button.height = "28px";
+        button.cornerRadius = 0;
+        button.background = this.#colorEnabled;
+        button.onPointerUpObservable.add(() => {
+            if (callback) {
+                callback();
+            }
+        });
+        this.#panel.addControl(button);
+    }
+
+    #createButtons() {
+        this.#addButton("closed", "../src/images/icon-skip-backward.svg", this.#callbacks.onGoToClosed);
+        this.#addButton("close", "../src/images/icon-play-backwards.svg", this.#callbacks.onClose);
+        this.#addButton("pause", "../src/images/icon-pause.svg", this.#callbacks.onPause);
+        this.#addButton("open", "../src/images/icon-play.svg", this.#callbacks.onOpen);
+        this.#addButton("opened", "../src/images/icon-skip-forward.svg", this.#callbacks.onGoToOpened);
+    }
+
+    #setButtonState(name, enabled, active) {
+        const button = this.#advancedDynamicTexture.getControlByName(`button_animation_${name}`);
+        if (!button) {
+            return;
+        }
+        button.background = active ? this.#colorActive : enabled ? this.#colorEnabled : this.#colorDisabled;
+    }
+
+    #setButtonsState() {
+        const goToOpenedButtonEnabled = this.#animationState !== OpeningAnimationController.states.opened;
+        const goToOpenedButtonActive = false;
+        const openButtonEnabled = this.#animationState !== OpeningAnimationController.states.opened && this.#animationState !== OpeningAnimationController.states.opening;
+        const openButtonActive = this.#animationState === OpeningAnimationController.states.opening;
+        const pauseButtonEnabled = this.#animationState !== OpeningAnimationController.states.paused && this.#animationState !== OpeningAnimationController.states.closed && this.#animationState !== OpeningAnimationController.states.opened;
+        const pauseButtonActive = this.#animationState === OpeningAnimationController.states.paused;
+        const closeButtonEnabled = this.#animationState !== OpeningAnimationController.states.closed && this.#animationState !== OpeningAnimationController.states.closing;
+        const closeButtonActive = this.#animationState === OpeningAnimationController.states.closing;
+        const goToClosedButtonEnabled = this.#animationState !== OpeningAnimationController.states.closed;
+        const goToClosedButtonActive = false;
+
+        this.#setButtonState("opened", goToOpenedButtonEnabled, goToOpenedButtonActive);
+        this.#setButtonState("open", openButtonEnabled, openButtonActive);
+        this.#setButtonState("pause", pauseButtonEnabled, pauseButtonActive);
+        this.#setButtonState("close", closeButtonEnabled, closeButtonActive);
+        this.#setButtonState("closed", goToClosedButtonEnabled, goToClosedButtonActive);
+    }
+
+    set animationState(state) {
+        this.#animationState = state;
+        this.#setButtonsState();
+    }
+}
+
+/**
+ * BabylonJSAnimationController - Manages animation playback and interactive highlighting for model containers in Babylon.js scenes.
+ *
+ * Responsibilities:
+ *  - Detects if the loaded model container contains animations.
+ *  - Controls playback state: playing forward, playing backward, paused.
+ *  - Tracks and manages animated transformation nodes.
+ *  - Highlights animated nodes when hovered by the cursor.
+ *  - Provides API for play, pause, reverse, and highlight operations.
+ */
+export default class BabylonJSAnimationController {
+    #scene = null;
+    #assetContainer = null;
+    #animatedNodes = [];
+    #highlightLayer = null;
+    #highlightColor = new Color3(0, 1, 0); // Color para resaltar los elementos animados (Verde)
+    #advancedDynamicTexture = null;
+    #openingAnimations = [];
+
+    /**
+     * @param {BABYLON.Scene} scene - The Babylon.js scene instance.
+     * @param {BABYLON.AssetContainer} assetContainer - The loaded asset container.
+     */
+    constructor(scene, assetContainer) {
+        this.#scene = scene;
+        this.#assetContainer = assetContainer;
+        this.#initializeAnimations();
+        this.#setupPointerObservers();
+    }
+
+    /**
+     * Detects and stores animatable objects and animated nodes in the model container.
+     * @private
+     */
+    #initializeAnimations() {
+        if (!this.#assetContainer.animationGroups.length) {
+            return;
+        }
+
+        this.#getAnimatedNodes();
+        this.#getOpeneingAnimations();
+    }
+
+    #getAnimatedNodes() {
+        this.#assetContainer.animationGroups.forEach((animationGroup) => {
+            if (!animationGroup._targetedAnimations.length) {
+                return;
+            }
+            animationGroup._targetedAnimations.forEach((targetedAnimation) => {
+                if (!this.#animatedNodes.includes(targetedAnimation.target.id)) {
+                    this.#animatedNodes.push(targetedAnimation.target.id);
+                }
+            });
+        });
+    }
+
+    #getOpeneingAnimations() {
+        const openings = {};
+        this.#assetContainer.animationGroups.forEach((animationGroup) => {
+            const match = animationGroup.name.match(/^animation_(open|close)_(.+)$/);
+            if (!match) {
+                return;
+            }
+            const [, type, openingName] = match;
+            if (!openings[openingName]) {
+                openings[openingName] = { name: openingName, animationOpen: null, animationClose: null };
+            }
+            if (type === "open") {
+                openings[openingName].animationOpen = animationGroup;
+            } else if (type === "close") {
+                openings[openingName].animationClose = animationGroup;
+            }
+        });
+
+        Object.values(openings).forEach((opening) => {
+            this.#openingAnimations.push(new OpeningAnimationController(opening.name, opening.animationOpen, opening.animationClose));
+        });
+    }
+
+    #getOpeningAnimationByNode(nodeId) {
+        return this.#openingAnimations.find((openingAnimation) => openingAnimation.isAnimationForNode(nodeId));
+    }
+
+    /**
+     * Busca si una malla pertenece a un nodo que es objetivo de alguna animación
+     * @param {BABYLON.Mesh} mesh Malla
+     * @param {Array} targetNodeIds Array con los identificadores de los nodos que son objetivo de alguna animación
+     * @returns {Array} Array de 2 posiciones: [0] Identificador del nodo que es objetivo de alguna animación (o false si no lo es), [1] Array con las mallas hijas del nodo que es objetivo de alguna animación (o vacío si no lo es)
+     * @description
+     * El segundo elemento del array devuelto es se necesita para poder resaltar esas mallas hijas cuando el puntero del ratón está sobre alguna de ellas
+     */
+    #getNodeAnimatedByMesh = function (mesh) {
+        let nodeId = false;
+        let node = mesh;
+        while (node.parent !== null && !nodeId) {
+            node = node.parent;
+            if (this.#animatedNodes.includes(node.id)) {
+                nodeId = node.id;
+            }
+        }
+        return nodeId;
+    };
+
+    /**
+     * Ilumina las mallas que son objetivo de alguna animación si el puntero del ratón está sobre una de ellas
+     * @param {BABYLON.PickingInfo} pickingInfo Información del trazado del rayo desde la cámara activa hasta el puntero del ratón
+     */
+    #hightlightMeshesForAnimation(pickingInfo) {
+        if (!this.#highlightLayer) {
+            this.#highlightLayer = new HighlightLayer("hl_animations", this.#scene);
+        }
+
+        this.#highlightLayer.removeAllMeshes();
+        if (!pickingInfo?.hit && !pickingInfo?.pickedMesh) {
+            return;
+        }
+
+        const nodeId = this.#getNodeAnimatedByMesh(pickingInfo.pickedMesh);
+        if (!nodeId) {
+            return;
+        }
+
+        const transformNode = this.#scene.getTransformNodeByID(nodeId);
+        const nodeMeshes = transformNode.getChildMeshes();
+        if (nodeMeshes.length) {
+            nodeMeshes.forEach((mesh) => this.#highlightLayer.addMesh(mesh, this.#highlightColor));
+        }
+    }
+
+    /**
+     * Sets up pointer observers to highlight animated nodes on hover.
+     * @private
+     */
+    #setupPointerObservers() {
+        this.#scene.onPointerObservable.add((pointerInfo) => {
+            if (pointerInfo.type === PointerEventTypes.POINTERMOVE) {
+                const pickingInfo = this.#scene.pick(pointerInfo.event.clientX, pointerInfo.event.clientY);
+                this.#hightlightMeshesForAnimation(pickingInfo);
+            }
+            if (pointerInfo.type === PointerEventTypes.POINTERUP) {
+                // Eliminar cualquier Babylon GUI que se haya creado anteriormente
+                if (this.#advancedDynamicTexture) {
+                    this.#advancedDynamicTexture.dispose();
+                    this.#advancedDynamicTexture = null;
+                }
+                const pickingInfo = this.#scene.pick(pointerInfo.event.clientX, pointerInfo.event.clientY);
+                this.#showMenu(pickingInfo);
+            }
+        });
+    }
+
+    #showMenu(pickingInfo) {
+        if (!pickingInfo?.hit && !pickingInfo?.pickedMesh) {
+            return;
+        }
+
+        const nodeId = this.#getNodeAnimatedByMesh(pickingInfo.pickedMesh);
+        if (!nodeId) {
+            return;
+        }
+        const openingAnimation = this.#getOpeningAnimationByNode(nodeId);
+        if (!openingAnimation) {
+            return;
+        }
+        if (!this.#advancedDynamicTexture) {
+            this.#advancedDynamicTexture = AdvancedDynamicTexture.CreateFullscreenUI("UI_Animation");
+        }
+        openingAnimation.showControls(this.#advancedDynamicTexture, pickingInfo.pickedMesh);
+    }
+}

package/src/babylonjs-controller.js

@@ -1,9 +1,11 @@
 import { Engine, Scene, ArcRotateCamera, Vector3, Color4, HemisphericLight, DirectionalLight, PointLight, ShadowGenerator, LoadAssetContainerAsync, Tools, WebXRSessionManager, WebXRDefaultExperience, MeshBuilder, WebXRFeatureName, HDRCubeTexture, IblShadowsRenderPipeline } from "@babylonjs/core";
+import { DracoCompression } from "@babylonjs/core/Meshes/Compression/dracoCompression";
 import "@babylonjs/loaders";
-import { USDZExportAsync, GLTF2Export } from "@babylonjs/serializers";
 import "@babylonjs/loaders/glTF/2.0/Extensions/KHR_draco_mesh_compression";
-import { DracoCompression } from "@babylonjs/core/Meshes/Compression/dracoCompression";
+import { USDZExportAsync, GLTF2Export } from "@babylonjs/serializers";
+
 import GLTFResolver from "./gltf-resolver.js";
+import BabylonJSAnimationController from "./babylonjs-animation-controller.js";
 
 /**
  * BabylonJSController - Main controller for managing Babylon.js 3D scenes, assets, and interactions.
@@ -76,6 +78,7 @@ export default class BabylonJSController {
     #options = {};
 
     #gltfResolver = null; // GLTFResolver instance
+    #babylonJSAnimationController = null; // AnimationController instance
 
     /**
      * Constructs a new BabylonJSController instance.
@@ -629,7 +632,7 @@ export default class BabylonJSController {
      * @private
      * @param {object} container - The container object containing asset state and metadata.
      * @param {object} newAssetContainer - The new asset container to add to the scene.
-     * @returns {boolean} True if the container was replaced, false otherwise.
+     * @returns {boolean} True if the container was replaced and added, false otherwise.
      */
     #replaceContainer(container, newAssetContainer) {
         if (container.assetContainer) {
@@ -639,8 +642,7 @@ export default class BabylonJSController {
         }
         this.#scene.getEngine().releaseEffects();
         container.assetContainer = newAssetContainer;
-        this.#addContainer(container);
-        return true;
+        return this.#addContainer(container);
     }
     /**
      * Sets the visibility of wall and floor meshes in the model container based on the provided value or environment visibility.
@@ -663,7 +665,6 @@ export default class BabylonJSController {
      * @private
      * @returns {void}
      */
-    #stopR;
     #stopRender() {
         this.#engine.stopRenderLoop(this.#renderLoop.bind(this));
     }
@@ -725,11 +726,11 @@ export default class BabylonJSController {
     /**
      * Loads all asset containers (model, environment, materials, etc.) and adds them to the scene.
      * @private
-     * @returns {Promise<boolean>} Resolves to true if loading succeeds, false otherwise.
+     * @returns {Promise<{success: boolean, error: any}>} Resolves to an object indicating if loading succeeded and any error encountered.
      * @description
      * Waits for all containers to load in parallel, then replaces or adds them to the scene as needed.
      * Applies material and camera options, sets wall/floor visibility, and initializes lights and shadows.
-     * Returns true if all containers loaded successfully, false otherwise.
+     * Returns an object with success status and error details.
      */
     async #loadContainers() {
         this.#stopRender();
@@ -739,7 +740,10 @@ export default class BabylonJSController {
             promiseArray.push(this.#loadAssetContainer(container));
         });
 
-        let success = false;
+        let detail = {
+            success: false,
+            error: null,
+        };
 
         await Promise.allSettled(promiseArray)
             .then((values) => {
@@ -750,7 +754,10 @@ export default class BabylonJSController {
                         if (container.state.name === "model") {
                             assetContainer.lights = [];
                         }
-                        this.#replaceContainer(container, assetContainer);
+                        const replacedAndAdded = this.#replaceContainer(container, assetContainer);
+                        if (replacedAndAdded && container.state.name === "model") {
+                            this.#babylonJSAnimationController = new BabylonJSAnimationController(this.#scene, assetContainer);
+                        }
                         container.state.setSuccess(true);
                     } else {
                         if (container.assetContainer && container.state.mustBeShown !== container.state.isVisible && container.state.name === "materials") {
@@ -763,21 +770,21 @@ export default class BabylonJSController {
                 this.#setOptions_Materials();
                 this.#setOptions_Camera();
                 this.#setVisibilityOfWallAndFloorInModel();
-                success = true;
+                detail.success = true;
             })
             .catch((error) => {
                 this.loaded = true;
                 console.error("PrefViewer: failed to load model", error);
-                success = false;
+                detail.success = false;
+                detail.error = error;
             })
             .finally(async () => {
                 this.#setMaxSimultaneousLights();
                 this.#initializeShadows();
                 this.#startRender();
-                return success;
             });
 
-        return success;
+        return detail;
     }
 
     /**