@spiffcommerce/preview 3.6.2-rc.8 → 4.0.0

package/dist/modelContainer.esm.js

@@ -1,1895 +0,0 @@
-import { _ as __awaiter } from './_tslib.esm.js';
-import { b as Vector2, V as Vector3, O as Observable, E as EngineStore, e as Vector4 } from './webRequest.esm.js';
-import { a as Color3, C as Color4, R as RegisterClass, G as GetClass } from './math.color.esm.js';
-import { L as Logger, f as AbstractActionManager, D as DeepCopier } from './engine.esm.js';
-import { P as PBRMaterial } from './pbrMaterial.esm.js';
-import { T as TransformNode, M as Mesh } from './mesh.esm.js';
-import { g as getAssetContainer } from './assetCache.esm2.js';
-import { attachDynamicTextures } from './dynamicTexture.esm.js';
-import { generateGuid } from './guid.esm.js';
-import { resetAnimationGroups, executeAnimationGroups } from './productAnimations.esm.js';
-import { V as VariantManager, g as getAllMaterialsForInstance } from './variants.esm2.js';
-import './helperFunctions.esm.js';
-import './math.size.esm.js';
-import './compatibilityOptions.esm.js';
-import './hdrFilteringFunctions.esm.js';
-import './pbrBRDFFunctions.esm.js';
-import './math.axis.esm.js';
-import './math.path.esm.js';
-import './material.esm2.js';
-import './node.esm.js';
-import './bumpVertex.esm.js';
-import './effectFallbacks.esm.js';
-import './sceneLoaderFlags.esm.js';
-import './dynamicTexture.esm2.js';
-import './renderConstants.esm.js';
-import './animation.esm.js';
-import './easing.esm.js';
-import './material.esm.js';
-import './types.esm.js';
-
-/**
- * The action to be carried out following a trigger
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#available-actions
- */
-class Action {
-    /**
-     * Creates a new Action
-     * @param triggerOptions the trigger, with or without parameters, for the action
-     * @param condition an optional determinant of action
-     */
-    constructor(
-    /** the trigger, with or without parameters, for the action */
-    triggerOptions, condition) {
-        this.triggerOptions = triggerOptions;
-        /**
-         * An event triggered prior to action being executed.
-         */
-        this.onBeforeExecuteObservable = new Observable();
-        if (triggerOptions.parameter) {
-            this.trigger = triggerOptions.trigger;
-            this._triggerParameter = triggerOptions.parameter;
-        }
-        else if (triggerOptions.trigger) {
-            this.trigger = triggerOptions.trigger;
-        }
-        else {
-            this.trigger = triggerOptions;
-        }
-        this._nextActiveAction = this;
-        this._condition = condition;
-    }
-    /**
-     * Internal only
-     * @internal
-     */
-    _prepare() { }
-    /**
-     * Gets the trigger parameter
-     * @returns the trigger parameter
-     */
-    getTriggerParameter() {
-        return this._triggerParameter;
-    }
-    /**
-     * Sets the trigger parameter
-     * @param value defines the new trigger parameter
-     */
-    setTriggerParameter(value) {
-        this._triggerParameter = value;
-    }
-    /**
-     * Internal only - Returns if the current condition allows to run the action
-     * @internal
-     */
-    _evaluateConditionForCurrentFrame() {
-        const condition = this._condition;
-        if (!condition) {
-            return true;
-        }
-        const currentRenderId = this._actionManager.getScene().getRenderId();
-        // We cache the current evaluation for the current frame
-        if (condition._evaluationId !== currentRenderId) {
-            condition._evaluationId = currentRenderId;
-            condition._currentResult = condition.isValid();
-        }
-        return condition._currentResult;
-    }
-    /**
-     * Internal only - executes current action event
-     * @internal
-     */
-    _executeCurrent(evt) {
-        const isConditionValid = this._evaluateConditionForCurrentFrame();
-        if (!isConditionValid) {
-            return;
-        }
-        this.onBeforeExecuteObservable.notifyObservers(this);
-        this._nextActiveAction.execute(evt);
-        this.skipToNextActiveAction();
-    }
-    /**
-     * Execute placeholder for child classes
-     * @param evt optional action event
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    execute(evt) { }
-    /**
-     * Skips to next active action
-     */
-    skipToNextActiveAction() {
-        if (this._nextActiveAction._child) {
-            if (!this._nextActiveAction._child._actionManager) {
-                this._nextActiveAction._child._actionManager = this._actionManager;
-            }
-            this._nextActiveAction = this._nextActiveAction._child;
-        }
-        else {
-            this._nextActiveAction = this;
-        }
-    }
-    /**
-     * Adds action to chain of actions, may be a DoNothingAction
-     * @param action defines the next action to execute
-     * @returns The action passed in
-     * @see https://www.babylonjs-playground.com/#1T30HR#0
-     */
-    then(action) {
-        this._child = action;
-        action._actionManager = this._actionManager;
-        action._prepare();
-        return action;
-    }
-    /**
-     * Internal only
-     * @internal
-     */
-    _getProperty(propertyPath) {
-        return this._actionManager._getProperty(propertyPath);
-    }
-    /**
-     * @internal
-     */
-    _getEffectiveTarget(target, propertyPath) {
-        return this._actionManager._getEffectiveTarget(target, propertyPath);
-    }
-    /**
-     * Serialize placeholder for child classes
-     * @param parent of child
-     * @returns the serialized object
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    serialize(parent) { }
-    /**
-     * Internal only called by serialize
-     * @internal
-     */
-    _serialize(serializedAction, parent) {
-        const serializationObject = {
-            type: 1,
-            children: [],
-            name: serializedAction.name,
-            properties: serializedAction.properties || [],
-        };
-        // Serialize child
-        if (this._child) {
-            this._child.serialize(serializationObject);
-        }
-        // Check if "this" has a condition
-        if (this._condition) {
-            const serializedCondition = this._condition.serialize();
-            serializedCondition.children.push(serializationObject);
-            if (parent) {
-                parent.children.push(serializedCondition);
-            }
-            return serializedCondition;
-        }
-        if (parent) {
-            parent.children.push(serializationObject);
-        }
-        return serializationObject;
-    }
-}
-/**
- * Internal only
- * @internal
- */
-Action._SerializeValueAsString = (value) => {
-    if (typeof value === "number") {
-        return value.toString();
-    }
-    if (typeof value === "boolean") {
-        return value ? "true" : "false";
-    }
-    if (value instanceof Vector2) {
-        return value.x + ", " + value.y;
-    }
-    if (value instanceof Vector3) {
-        return value.x + ", " + value.y + ", " + value.z;
-    }
-    if (value instanceof Color3) {
-        return value.r + ", " + value.g + ", " + value.b;
-    }
-    if (value instanceof Color4) {
-        return value.r + ", " + value.g + ", " + value.b + ", " + value.a;
-    }
-    return value; // string
-};
-/**
- * Internal only
- * @internal
- */
-Action._GetTargetProperty = (target) => {
-    return {
-        name: "target",
-        targetType: target._isMesh
-            ? "MeshProperties"
-            : target._isLight
-                ? "LightProperties"
-                : target._isCamera
-                    ? "CameraProperties"
-                    : target._isMaterial
-                        ? "MaterialProperties"
-                        : "SceneProperties",
-        value: target._isScene ? "Scene" : target.name,
-    };
-};
-RegisterClass("BABYLON.Action", Action);
-
-/**
- * A Condition applied to an Action
- */
-class Condition {
-    /**
-     * Creates a new Condition
-     * @param actionManager the manager of the action the condition is applied to
-     */
-    constructor(actionManager) {
-        this._actionManager = actionManager;
-    }
-    /**
-     * Check if the current condition is valid
-     * @returns a boolean
-     */
-    isValid() {
-        return true;
-    }
-    /**
-     * @internal
-     */
-    _getProperty(propertyPath) {
-        return this._actionManager._getProperty(propertyPath);
-    }
-    /**
-     * @internal
-     */
-    _getEffectiveTarget(target, propertyPath) {
-        return this._actionManager._getEffectiveTarget(target, propertyPath);
-    }
-    /**
-     * Serialize placeholder for child classes
-     * @returns the serialized object
-     */
-    serialize() { }
-    /**
-     * @internal
-     */
-    _serialize(serializedCondition) {
-        return {
-            type: 2,
-            children: [],
-            name: serializedCondition.name,
-            properties: serializedCondition.properties,
-        };
-    }
-}
-/**
- * Defines specific conditional operators as extensions of Condition
- */
-class ValueCondition extends Condition {
-    /**
-     * returns the number for IsEqual
-     */
-    static get IsEqual() {
-        return ValueCondition._IsEqual;
-    }
-    /**
-     * Returns the number for IsDifferent
-     */
-    static get IsDifferent() {
-        return ValueCondition._IsDifferent;
-    }
-    /**
-     * Returns the number for IsGreater
-     */
-    static get IsGreater() {
-        return ValueCondition._IsGreater;
-    }
-    /**
-     * Returns the number for IsLesser
-     */
-    static get IsLesser() {
-        return ValueCondition._IsLesser;
-    }
-    /**
-     * Creates a new ValueCondition
-     * @param actionManager manager for the action the condition applies to
-     * @param target for the action
-     * @param propertyPath path to specify the property of the target the conditional operator uses
-     * @param value the value compared by the conditional operator against the current value of the property
-     * @param operator the conditional operator, default ValueCondition.IsEqual
-     */
-    constructor(actionManager, target, 
-    /** path to specify the property of the target the conditional operator uses  */
-    propertyPath, 
-    /** the value compared by the conditional operator against the current value of the property */
-    value, 
-    /** the conditional operator, default ValueCondition.IsEqual */
-    operator = ValueCondition.IsEqual) {
-        super(actionManager);
-        this.propertyPath = propertyPath;
-        this.value = value;
-        this.operator = operator;
-        this._target = target;
-        this._effectiveTarget = this._getEffectiveTarget(target, this.propertyPath);
-        this._property = this._getProperty(this.propertyPath);
-    }
-    /**
-     * Compares the given value with the property value for the specified conditional operator
-     * @returns the result of the comparison
-     */
-    isValid() {
-        switch (this.operator) {
-            case ValueCondition.IsGreater:
-                return this._effectiveTarget[this._property] > this.value;
-            case ValueCondition.IsLesser:
-                return this._effectiveTarget[this._property] < this.value;
-            case ValueCondition.IsEqual:
-            case ValueCondition.IsDifferent: {
-                let check;
-                if (this.value.equals) {
-                    check = this.value.equals(this._effectiveTarget[this._property]);
-                }
-                else {
-                    check = this.value === this._effectiveTarget[this._property];
-                }
-                return this.operator === ValueCondition.IsEqual ? check : !check;
-            }
-        }
-        return false;
-    }
-    /**
-     * Serialize the ValueCondition into a JSON compatible object
-     * @returns serialization object
-     */
-    serialize() {
-        return this._serialize({
-            name: "ValueCondition",
-            properties: [
-                Action._GetTargetProperty(this._target),
-                { name: "propertyPath", value: this.propertyPath },
-                { name: "value", value: Action._SerializeValueAsString(this.value) },
-                { name: "operator", value: ValueCondition.GetOperatorName(this.operator) },
-            ],
-        });
-    }
-    /**
-     * Gets the name of the conditional operator for the ValueCondition
-     * @param operator the conditional operator
-     * @returns the name
-     */
-    static GetOperatorName(operator) {
-        switch (operator) {
-            case ValueCondition._IsEqual:
-                return "IsEqual";
-            case ValueCondition._IsDifferent:
-                return "IsDifferent";
-            case ValueCondition._IsGreater:
-                return "IsGreater";
-            case ValueCondition._IsLesser:
-                return "IsLesser";
-            default:
-                return "";
-        }
-    }
-}
-ValueCondition._IsEqual = 0;
-ValueCondition._IsDifferent = 1;
-ValueCondition._IsGreater = 2;
-ValueCondition._IsLesser = 3;
-/**
- * Defines a predicate condition as an extension of Condition
- */
-class PredicateCondition extends Condition {
-    /**
-     * Creates a new PredicateCondition
-     * @param actionManager manager for the action the condition applies to
-     * @param predicate defines the predicate function used to validate the condition
-     */
-    constructor(actionManager, 
-    /** defines the predicate function used to validate the condition */
-    predicate) {
-        super(actionManager);
-        this.predicate = predicate;
-    }
-    /**
-     * @returns the validity of the predicate condition
-     */
-    isValid() {
-        return this.predicate();
-    }
-}
-/**
- * Defines a state condition as an extension of Condition
- */
-class StateCondition extends Condition {
-    /**
-     * Creates a new StateCondition
-     * @param actionManager manager for the action the condition applies to
-     * @param target of the condition
-     * @param value to compare with target state
-     */
-    constructor(actionManager, target, 
-    /** Value to compare with target state  */
-    value) {
-        super(actionManager);
-        this.value = value;
-        this._target = target;
-    }
-    /**
-     * Gets a boolean indicating if the current condition is met
-     * @returns the validity of the state
-     */
-    isValid() {
-        return this._target.state === this.value;
-    }
-    /**
-     * Serialize the StateCondition into a JSON compatible object
-     * @returns serialization object
-     */
-    serialize() {
-        return this._serialize({
-            name: "StateCondition",
-            properties: [Action._GetTargetProperty(this._target), { name: "value", value: this.value }],
-        });
-    }
-}
-RegisterClass("BABYLON.ValueCondition", ValueCondition);
-RegisterClass("BABYLON.PredicateCondition", PredicateCondition);
-RegisterClass("BABYLON.StateCondition", StateCondition);
-
-/**
- * This defines an action responsible to toggle a boolean once triggered.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions
- */
-class SwitchBooleanAction extends Action {
-    /**
-     * Instantiate the action
-     * @param triggerOptions defines the trigger options
-     * @param target defines the object containing the boolean
-     * @param propertyPath defines the path to the boolean property in the target object
-     * @param condition defines the trigger related conditions
-     */
-    constructor(triggerOptions, target, propertyPath, condition) {
-        super(triggerOptions, condition);
-        this.propertyPath = propertyPath;
-        this._target = this._effectiveTarget = target;
-    }
-    /** @internal */
-    _prepare() {
-        this._effectiveTarget = this._getEffectiveTarget(this._effectiveTarget, this.propertyPath);
-        this._property = this._getProperty(this.propertyPath);
-    }
-    /**
-     * Execute the action toggle the boolean value.
-     */
-    execute() {
-        this._effectiveTarget[this._property] = !this._effectiveTarget[this._property];
-    }
-    /**
-     * Serializes the actions and its related information.
-     * @param parent defines the object to serialize in
-     * @returns the serialized object
-     */
-    serialize(parent) {
-        return super._serialize({
-            name: "SwitchBooleanAction",
-            properties: [Action._GetTargetProperty(this._target), { name: "propertyPath", value: this.propertyPath }],
-        }, parent);
-    }
-}
-/**
- * This defines an action responsible to set a the state field of the target
- *  to a desired value once triggered.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions
- */
-class SetStateAction extends Action {
-    /**
-     * Instantiate the action
-     * @param triggerOptions defines the trigger options
-     * @param target defines the object containing the state property
-     * @param value defines the value to store in the state field
-     * @param condition defines the trigger related conditions
-     */
-    constructor(triggerOptions, target, value, condition) {
-        super(triggerOptions, condition);
-        this.value = value;
-        this._target = target;
-    }
-    /**
-     * Execute the action and store the value on the target state property.
-     */
-    execute() {
-        this._target.state = this.value;
-    }
-    /**
-     * Serializes the actions and its related information.
-     * @param parent defines the object to serialize in
-     * @returns the serialized object
-     */
-    serialize(parent) {
-        return super._serialize({
-            name: "SetStateAction",
-            properties: [Action._GetTargetProperty(this._target), { name: "value", value: this.value }],
-        }, parent);
-    }
-}
-/**
- * This defines an action responsible to set a property of the target
- *  to a desired value once triggered.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions
- */
-class SetValueAction extends Action {
-    /**
-     * Instantiate the action
-     * @param triggerOptions defines the trigger options
-     * @param target defines the object containing the property
-     * @param propertyPath defines the path of the property to set in the target
-     * @param value defines the value to set in the property
-     * @param condition defines the trigger related conditions
-     */
-    constructor(triggerOptions, target, propertyPath, value, condition) {
-        super(triggerOptions, condition);
-        this.propertyPath = propertyPath;
-        this.value = value;
-        this._target = this._effectiveTarget = target;
-    }
-    /** @internal */
-    _prepare() {
-        this._effectiveTarget = this._getEffectiveTarget(this._effectiveTarget, this.propertyPath);
-        this._property = this._getProperty(this.propertyPath);
-    }
-    /**
-     * Execute the action and set the targeted property to the desired value.
-     */
-    execute() {
-        this._effectiveTarget[this._property] = this.value;
-        if (this._target.markAsDirty) {
-            this._target.markAsDirty(this._property);
-        }
-    }
-    /**
-     * Serializes the actions and its related information.
-     * @param parent defines the object to serialize in
-     * @returns the serialized object
-     */
-    serialize(parent) {
-        return super._serialize({
-            name: "SetValueAction",
-            properties: [
-                Action._GetTargetProperty(this._target),
-                { name: "propertyPath", value: this.propertyPath },
-                { name: "value", value: Action._SerializeValueAsString(this.value) },
-            ],
-        }, parent);
-    }
-}
-/**
- * This defines an action responsible to increment the target value
- *  to a desired value once triggered.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions
- */
-class IncrementValueAction extends Action {
-    /**
-     * Instantiate the action
-     * @param triggerOptions defines the trigger options
-     * @param target defines the object containing the property
-     * @param propertyPath defines the path of the property to increment in the target
-     * @param value defines the value value we should increment the property by
-     * @param condition defines the trigger related conditions
-     */
-    constructor(triggerOptions, target, propertyPath, value, condition) {
-        super(triggerOptions, condition);
-        this.propertyPath = propertyPath;
-        this.value = value;
-        this._target = this._effectiveTarget = target;
-    }
-    /** @internal */
-    _prepare() {
-        this._effectiveTarget = this._getEffectiveTarget(this._effectiveTarget, this.propertyPath);
-        this._property = this._getProperty(this.propertyPath);
-        if (typeof this._effectiveTarget[this._property] !== "number") {
-            Logger.Warn("Warning: IncrementValueAction can only be used with number values");
-        }
-    }
-    /**
-     * Execute the action and increment the target of the value amount.
-     */
-    execute() {
-        this._effectiveTarget[this._property] += this.value;
-        if (this._target.markAsDirty) {
-            this._target.markAsDirty(this._property);
-        }
-    }
-    /**
-     * Serializes the actions and its related information.
-     * @param parent defines the object to serialize in
-     * @returns the serialized object
-     */
-    serialize(parent) {
-        return super._serialize({
-            name: "IncrementValueAction",
-            properties: [
-                Action._GetTargetProperty(this._target),
-                { name: "propertyPath", value: this.propertyPath },
-                { name: "value", value: Action._SerializeValueAsString(this.value) },
-            ],
-        }, parent);
-    }
-}
-/**
- * This defines an action responsible to start an animation once triggered.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions
- */
-class PlayAnimationAction extends Action {
-    /**
-     * Instantiate the action
-     * @param triggerOptions defines the trigger options
-     * @param target defines the target animation or animation name
-     * @param from defines from where the animation should start (animation frame)
-     * @param to defines where the animation should stop (animation frame)
-     * @param loop defines if the animation should loop or stop after the first play
-     * @param condition defines the trigger related conditions
-     */
-    constructor(triggerOptions, target, from, to, loop, condition) {
-        super(triggerOptions, condition);
-        this.from = from;
-        this.to = to;
-        this.loop = loop;
-        this._target = target;
-    }
-    /** @internal */
-    _prepare() { }
-    /**
-     * Execute the action and play the animation.
-     */
-    execute() {
-        const scene = this._actionManager.getScene();
-        scene.beginAnimation(this._target, this.from, this.to, this.loop);
-    }
-    /**
-     * Serializes the actions and its related information.
-     * @param parent defines the object to serialize in
-     * @returns the serialized object
-     */
-    serialize(parent) {
-        return super._serialize({
-            name: "PlayAnimationAction",
-            properties: [
-                Action._GetTargetProperty(this._target),
-                { name: "from", value: String(this.from) },
-                { name: "to", value: String(this.to) },
-                { name: "loop", value: Action._SerializeValueAsString(this.loop) || false },
-            ],
-        }, parent);
-    }
-}
-/**
- * This defines an action responsible to stop an animation once triggered.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions
- */
-class StopAnimationAction extends Action {
-    /**
-     * Instantiate the action
-     * @param triggerOptions defines the trigger options
-     * @param target defines the target animation or animation name
-     * @param condition defines the trigger related conditions
-     */
-    constructor(triggerOptions, target, condition) {
-        super(triggerOptions, condition);
-        this._target = target;
-    }
-    /** @internal */
-    _prepare() { }
-    /**
-     * Execute the action and stop the animation.
-     */
-    execute() {
-        const scene = this._actionManager.getScene();
-        scene.stopAnimation(this._target);
-    }
-    /**
-     * Serializes the actions and its related information.
-     * @param parent defines the object to serialize in
-     * @returns the serialized object
-     */
-    serialize(parent) {
-        return super._serialize({
-            name: "StopAnimationAction",
-            properties: [Action._GetTargetProperty(this._target)],
-        }, parent);
-    }
-}
-/**
- * This defines an action responsible that does nothing once triggered.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions
- */
-class DoNothingAction extends Action {
-    /**
-     * Instantiate the action
-     * @param triggerOptions defines the trigger options
-     * @param condition defines the trigger related conditions
-     */
-    constructor(triggerOptions = 0, condition) {
-        super(triggerOptions, condition);
-    }
-    /**
-     * Execute the action and do nothing.
-     */
-    execute() { }
-    /**
-     * Serializes the actions and its related information.
-     * @param parent defines the object to serialize in
-     * @returns the serialized object
-     */
-    serialize(parent) {
-        return super._serialize({
-            name: "DoNothingAction",
-            properties: [],
-        }, parent);
-    }
-}
-/**
- * This defines an action responsible to trigger several actions once triggered.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions
- */
-class CombineAction extends Action {
-    /**
-     * Instantiate the action
-     * @param triggerOptions defines the trigger options
-     * @param children defines the list of aggregated animations to run
-     * @param condition defines the trigger related conditions
-     * @param enableChildrenConditions defines if the children actions conditions should be check before execution
-     */
-    constructor(triggerOptions, children, condition, enableChildrenConditions = true) {
-        super(triggerOptions, condition);
-        this.children = children;
-        this.enableChildrenConditions = enableChildrenConditions;
-    }
-    /** @internal */
-    _prepare() {
-        for (let index = 0; index < this.children.length; index++) {
-            this.children[index]._actionManager = this._actionManager;
-            this.children[index]._prepare();
-        }
-    }
-    /**
-     * Execute the action and executes all the aggregated actions.
-     * @param evt
-     */
-    execute(evt) {
-        for (const action of this.children) {
-            if (!this.enableChildrenConditions || action._evaluateConditionForCurrentFrame()) {
-                action.execute(evt);
-            }
-        }
-    }
-    /**
-     * Serializes the actions and its related information.
-     * @param parent defines the object to serialize in
-     * @returns the serialized object
-     */
-    serialize(parent) {
-        const serializationObject = super._serialize({
-            name: "CombineAction",
-            properties: [],
-            combine: [],
-        }, parent);
-        for (let i = 0; i < this.children.length; i++) {
-            serializationObject.combine.push(this.children[i].serialize(null));
-        }
-        return serializationObject;
-    }
-}
-/**
- * This defines an action responsible to run code (external event) once triggered.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions
- */
-class ExecuteCodeAction extends Action {
-    /**
-     * Instantiate the action
-     * @param triggerOptions defines the trigger options
-     * @param func defines the callback function to run
-     * @param condition defines the trigger related conditions
-     */
-    constructor(triggerOptions, func, condition) {
-        super(triggerOptions, condition);
-        this.func = func;
-    }
-    /**
-     * Execute the action and run the attached code.
-     * @param evt
-     */
-    execute(evt) {
-        this.func(evt);
-    }
-}
-/**
- * This defines an action responsible to set the parent property of the target once triggered.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions
- */
-class SetParentAction extends Action {
-    /**
-     * Instantiate the action
-     * @param triggerOptions defines the trigger options
-     * @param target defines the target containing the parent property
-     * @param parent defines from where the animation should start (animation frame)
-     * @param condition defines the trigger related conditions
-     */
-    constructor(triggerOptions, target, parent, condition) {
-        super(triggerOptions, condition);
-        this._target = target;
-        this._parent = parent;
-    }
-    /** @internal */
-    _prepare() { }
-    /**
-     * Execute the action and set the parent property.
-     */
-    execute() {
-        if (this._target.parent === this._parent) {
-            return;
-        }
-        const invertParentWorldMatrix = this._parent.getWorldMatrix().clone();
-        invertParentWorldMatrix.invert();
-        this._target.position = Vector3.TransformCoordinates(this._target.position, invertParentWorldMatrix);
-        this._target.parent = this._parent;
-    }
-    /**
-     * Serializes the actions and its related information.
-     * @param parent defines the object to serialize in
-     * @returns the serialized object
-     */
-    serialize(parent) {
-        return super._serialize({
-            name: "SetParentAction",
-            properties: [Action._GetTargetProperty(this._target), Action._GetTargetProperty(this._parent)],
-        }, parent);
-    }
-}
-RegisterClass("BABYLON.SetParentAction", SetParentAction);
-RegisterClass("BABYLON.ExecuteCodeAction", ExecuteCodeAction);
-RegisterClass("BABYLON.DoNothingAction", DoNothingAction);
-RegisterClass("BABYLON.StopAnimationAction", StopAnimationAction);
-RegisterClass("BABYLON.PlayAnimationAction", PlayAnimationAction);
-RegisterClass("BABYLON.IncrementValueAction", IncrementValueAction);
-RegisterClass("BABYLON.SetValueAction", SetValueAction);
-RegisterClass("BABYLON.SetStateAction", SetStateAction);
-RegisterClass("BABYLON.SetParentAction", SetParentAction);
-RegisterClass("BABYLON.SwitchBooleanAction", SwitchBooleanAction);
-RegisterClass("BABYLON.CombineAction", CombineAction);
-
-/**
- * Action Manager manages all events to be triggered on a given mesh or the global scene.
- * A single scene can have many Action Managers to handle predefined actions on specific meshes.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions
- */
-class ActionManager extends AbstractActionManager {
-    /**
-     * Creates a new action manager
-     * @param scene defines the hosting scene
-     */
-    constructor(scene) {
-        super();
-        scene = scene || EngineStore.LastCreatedScene;
-        if (!scene) {
-            return;
-        }
-        this._scene = scene;
-        scene.actionManagers.push(this);
-    }
-    // Methods
-    /**
-     * Releases all associated resources
-     */
-    dispose() {
-        const index = this._scene.actionManagers.indexOf(this);
-        for (let i = 0; i < this.actions.length; i++) {
-            const action = this.actions[i];
-            ActionManager.Triggers[action.trigger]--;
-            if (ActionManager.Triggers[action.trigger] === 0) {
-                delete ActionManager.Triggers[action.trigger];
-            }
-        }
-        if (index > -1) {
-            this._scene.actionManagers.splice(index, 1);
-        }
-    }
-    /**
-     * Gets hosting scene
-     * @returns the hosting scene
-     */
-    getScene() {
-        return this._scene;
-    }
-    /**
-     * Does this action manager handles actions of any of the given triggers
-     * @param triggers defines the triggers to be tested
-     * @returns a boolean indicating whether one (or more) of the triggers is handled
-     */
-    hasSpecificTriggers(triggers) {
-        for (let index = 0; index < this.actions.length; index++) {
-            const action = this.actions[index];
-            if (triggers.indexOf(action.trigger) > -1) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Does this action manager handles actions of any of the given triggers. This function takes two arguments for
-     * speed.
-     * @param triggerA defines the trigger to be tested
-     * @param triggerB defines the trigger to be tested
-     * @returns a boolean indicating whether one (or more) of the triggers is handled
-     */
-    hasSpecificTriggers2(triggerA, triggerB) {
-        for (let index = 0; index < this.actions.length; index++) {
-            const action = this.actions[index];
-            if (triggerA == action.trigger || triggerB == action.trigger) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Does this action manager handles actions of a given trigger
-     * @param trigger defines the trigger to be tested
-     * @param parameterPredicate defines an optional predicate to filter triggers by parameter
-     * @returns whether the trigger is handled
-     */
-    hasSpecificTrigger(trigger, parameterPredicate) {
-        for (let index = 0; index < this.actions.length; index++) {
-            const action = this.actions[index];
-            if (action.trigger === trigger) {
-                if (parameterPredicate) {
-                    if (parameterPredicate(action.getTriggerParameter())) {
-                        return true;
-                    }
-                }
-                else {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    /**
-     * Does this action manager has pointer triggers
-     */
-    get hasPointerTriggers() {
-        for (let index = 0; index < this.actions.length; index++) {
-            const action = this.actions[index];
-            if (action.trigger >= ActionManager.OnPickTrigger && action.trigger <= ActionManager.OnPointerOutTrigger) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Does this action manager has pick triggers
-     */
-    get hasPickTriggers() {
-        for (let index = 0; index < this.actions.length; index++) {
-            const action = this.actions[index];
-            if (action.trigger >= ActionManager.OnPickTrigger && action.trigger <= ActionManager.OnPickUpTrigger) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Registers an action to this action manager
-     * @param action defines the action to be registered
-     * @returns the action amended (prepared) after registration
-     */
-    registerAction(action) {
-        if (action.trigger === ActionManager.OnEveryFrameTrigger) {
-            if (this.getScene().actionManager !== this) {
-                Logger.Warn("OnEveryFrameTrigger can only be used with scene.actionManager");
-                return null;
-            }
-        }
-        this.actions.push(action);
-        this.getScene()._registeredActions++;
-        if (ActionManager.Triggers[action.trigger]) {
-            ActionManager.Triggers[action.trigger]++;
-        }
-        else {
-            ActionManager.Triggers[action.trigger] = 1;
-        }
-        action._actionManager = this;
-        action._prepare();
-        return action;
-    }
-    /**
-     * Unregisters an action to this action manager
-     * @param action defines the action to be unregistered
-     * @returns a boolean indicating whether the action has been unregistered
-     */
-    unregisterAction(action) {
-        const index = this.actions.indexOf(action);
-        if (index !== -1) {
-            this.actions.splice(index, 1);
-            ActionManager.Triggers[action.trigger] -= 1;
-            if (ActionManager.Triggers[action.trigger] === 0) {
-                delete ActionManager.Triggers[action.trigger];
-            }
-            action._actionManager = null;
-            this.getScene()._registeredActions--;
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Process a specific trigger
-     * @param trigger defines the trigger to process
-     * @param evt defines the event details to be processed
-     */
-    processTrigger(trigger, evt) {
-        for (let index = 0; index < this.actions.length; index++) {
-            const action = this.actions[index];
-            if (action.trigger === trigger) {
-                if (evt) {
-                    if (trigger === ActionManager.OnKeyUpTrigger || trigger === ActionManager.OnKeyDownTrigger) {
-                        const parameter = action.getTriggerParameter();
-                        if (typeof parameter === "function") {
-                            if (!parameter(evt)) {
-                                continue;
-                            }
-                        }
-                        else if (parameter && parameter !== evt.sourceEvent.keyCode) {
-                            if (!parameter.toLowerCase) {
-                                continue;
-                            }
-                            const lowerCase = parameter.toLowerCase();
-                            if (lowerCase !== evt.sourceEvent.key) {
-                                const unicode = evt.sourceEvent.charCode ? evt.sourceEvent.charCode : evt.sourceEvent.keyCode;
-                                const actualkey = String.fromCharCode(unicode).toLowerCase();
-                                if (actualkey !== lowerCase) {
-                                    continue;
-                                }
-                            }
-                        }
-                    }
-                }
-                action._executeCurrent(evt);
-            }
-        }
-    }
-    /**
-     * @internal
-     */
-    _getEffectiveTarget(target, propertyPath) {
-        const properties = propertyPath.split(".");
-        for (let index = 0; index < properties.length - 1; index++) {
-            target = target[properties[index]];
-        }
-        return target;
-    }
-    /**
-     * @internal
-     */
-    _getProperty(propertyPath) {
-        const properties = propertyPath.split(".");
-        return properties[properties.length - 1];
-    }
-    /**
-     * Serialize this manager to a JSON object
-     * @param name defines the property name to store this manager
-     * @returns a JSON representation of this manager
-     */
-    serialize(name) {
-        const root = {
-            children: new Array(),
-            name: name,
-            type: 3,
-            properties: new Array(), // Empty for root but required
-        };
-        for (let i = 0; i < this.actions.length; i++) {
-            const triggerObject = {
-                type: 0,
-                children: new Array(),
-                name: ActionManager.GetTriggerName(this.actions[i].trigger),
-                properties: new Array(),
-            };
-            const triggerOptions = this.actions[i].triggerOptions;
-            if (triggerOptions && typeof triggerOptions !== "number") {
-                if (triggerOptions.parameter instanceof Node) {
-                    triggerObject.properties.push(Action._GetTargetProperty(triggerOptions.parameter));
-                }
-                else if (typeof triggerOptions.parameter === "object") {
-                    const parameter = {};
-                    DeepCopier.DeepCopy(triggerOptions.parameter, parameter, ["mesh"]);
-                    if (triggerOptions.parameter && triggerOptions.parameter.mesh) {
-                        parameter._meshId = triggerOptions.parameter.mesh.id;
-                    }
-                    triggerObject.properties.push({ name: "parameter", targetType: null, value: parameter });
-                }
-                else {
-                    triggerObject.properties.push({ name: "parameter", targetType: null, value: triggerOptions.parameter });
-                }
-            }
-            // Serialize child action, recursively
-            this.actions[i].serialize(triggerObject);
-            // Add serialized trigger
-            root.children.push(triggerObject);
-        }
-        return root;
-    }
-    /**
-     * Creates a new ActionManager from a JSON data
-     * @param parsedActions defines the JSON data to read from
-     * @param object defines the hosting mesh
-     * @param scene defines the hosting scene
-     */
-    static Parse(parsedActions, object, scene) {
-        const actionManager = new ActionManager(scene);
-        if (object === null) {
-            scene.actionManager = actionManager;
-        }
-        else {
-            object.actionManager = actionManager;
-        }
-        // instantiate a new object
-        const instantiate = (name, params) => {
-            const internalClassType = GetClass("BABYLON." + name);
-            return internalClassType && new internalClassType(...params);
-        };
-        const parseParameter = (name, value, target, propertyPath) => {
-            if (propertyPath === null) {
-                // String, boolean or float
-                const floatValue = parseFloat(value);
-                if (value === "true" || value === "false") {
-                    return value === "true";
-                }
-                else {
-                    return isNaN(floatValue) ? value : floatValue;
-                }
-            }
-            const effectiveTarget = propertyPath.split(".");
-            const values = value.split(",");
-            // Get effective Target
-            for (let i = 0; i < effectiveTarget.length; i++) {
-                target = target[effectiveTarget[i]];
-            }
-            // Return appropriate value with its type
-            if (typeof target === "boolean") {
-                return values[0] === "true";
-            }
-            if (typeof target === "string") {
-                return values[0];
-            }
-            // Parameters with multiple values such as Vector3 etc.
-            const split = new Array();
-            for (let i = 0; i < values.length; i++) {
-                split.push(parseFloat(values[i]));
-            }
-            if (target instanceof Vector3) {
-                return Vector3.FromArray(split);
-            }
-            if (target instanceof Vector4) {
-                return Vector4.FromArray(split);
-            }
-            if (target instanceof Color3) {
-                return Color3.FromArray(split);
-            }
-            if (target instanceof Color4) {
-                return Color4.FromArray(split);
-            }
-            return parseFloat(values[0]);
-        };
-        // traverse graph per trigger
-        const traverse = (parsedAction, trigger, condition, action, combineArray = null) => {
-            if (parsedAction.detached) {
-                return;
-            }
-            const parameters = new Array();
-            let target = null;
-            let propertyPath = null;
-            const combine = parsedAction.combine && parsedAction.combine.length > 0;
-            // Parameters
-            if (parsedAction.type === 2) {
-                parameters.push(actionManager);
-            }
-            else {
-                parameters.push(trigger);
-            }
-            if (combine) {
-                const actions = new Array();
-                for (let j = 0; j < parsedAction.combine.length; j++) {
-                    traverse(parsedAction.combine[j], ActionManager.NothingTrigger, condition, action, actions);
-                }
-                parameters.push(actions);
-            }
-            else {
-                for (let i = 0; i < parsedAction.properties.length; i++) {
-                    let value = parsedAction.properties[i].value;
-                    const name = parsedAction.properties[i].name;
-                    const targetType = parsedAction.properties[i].targetType;
-                    if (name === "target") {
-                        if (targetType === "SceneProperties") {
-                            value = target = scene;
-                        }
-                        else if (targetType === "MaterialProperties") {
-                            value = target = scene.getMaterialByName(value);
-                        }
-                        else {
-                            value = target = scene.getNodeByName(value);
-                        }
-                    }
-                    else if (name === "parent") {
-                        value = scene.getNodeByName(value);
-                    }
-                    else if (name === "sound") {
-                        // Can not externalize to component, so only checks for the presence off the API.
-                        if (scene.getSoundByName) {
-                            value = scene.getSoundByName(value);
-                        }
-                    }
-                    else if (name !== "propertyPath") {
-                        if (parsedAction.type === 2 && name === "operator") {
-                            value = ValueCondition[value];
-                        }
-                        else {
-                            value = parseParameter(name, value, target, name === "value" ? propertyPath : null);
-                        }
-                    }
-                    else {
-                        propertyPath = value;
-                    }
-                    parameters.push(value);
-                }
-            }
-            if (combineArray === null) {
-                parameters.push(condition);
-            }
-            else {
-                parameters.push(null);
-            }
-            // If interpolate value action
-            if (parsedAction.name === "InterpolateValueAction") {
-                const param = parameters[parameters.length - 2];
-                parameters[parameters.length - 1] = param;
-                parameters[parameters.length - 2] = condition;
-            }
-            // Action or condition(s) and not CombineAction
-            let newAction = instantiate(parsedAction.name, parameters);
-            if (newAction instanceof Condition && condition !== null) {
-                const nothing = new DoNothingAction(trigger, condition);
-                if (action) {
-                    action.then(nothing);
-                }
-                else {
-                    actionManager.registerAction(nothing);
-                }
-                action = nothing;
-            }
-            if (combineArray === null) {
-                if (newAction instanceof Condition) {
-                    condition = newAction;
-                    newAction = action;
-                }
-                else {
-                    condition = null;
-                    if (action) {
-                        action.then(newAction);
-                    }
-                    else {
-                        actionManager.registerAction(newAction);
-                    }
-                }
-            }
-            else {
-                combineArray.push(newAction);
-            }
-            for (let i = 0; i < parsedAction.children.length; i++) {
-                traverse(parsedAction.children[i], trigger, condition, newAction, null);
-            }
-        };
-        // triggers
-        for (let i = 0; i < parsedActions.children.length; i++) {
-            let triggerParams;
-            const trigger = parsedActions.children[i];
-            if (trigger.properties.length > 0) {
-                const param = trigger.properties[0].value;
-                const value = trigger.properties[0].targetType === null ? param : scene.getMeshByName(param);
-                if (value._meshId) {
-                    value.mesh = scene.getMeshById(value._meshId);
-                }
-                triggerParams = { trigger: ActionManager[trigger.name], parameter: value };
-            }
-            else {
-                triggerParams = ActionManager[trigger.name];
-            }
-            for (let j = 0; j < trigger.children.length; j++) {
-                if (!trigger.detached) {
-                    traverse(trigger.children[j], triggerParams, null, null);
-                }
-            }
-        }
-    }
-    /**
-     * Get a trigger name by index
-     * @param trigger defines the trigger index
-     * @returns a trigger name
-     */
-    static GetTriggerName(trigger) {
-        switch (trigger) {
-            case 0:
-                return "NothingTrigger";
-            case 1:
-                return "OnPickTrigger";
-            case 2:
-                return "OnLeftPickTrigger";
-            case 3:
-                return "OnRightPickTrigger";
-            case 4:
-                return "OnCenterPickTrigger";
-            case 5:
-                return "OnPickDownTrigger";
-            case 6:
-                return "OnDoublePickTrigger"; // start;
-            case 7:
-                return "OnPickUpTrigger";
-            case 8:
-                return "OnLongPressTrigger";
-            case 9:
-                return "OnPointerOverTrigger";
-            case 10:
-                return "OnPointerOutTrigger";
-            case 11:
-                return "OnEveryFrameTrigger";
-            case 12:
-                return "OnIntersectionEnterTrigger";
-            case 13:
-                return "OnIntersectionExitTrigger";
-            case 14:
-                return "OnKeyDownTrigger";
-            case 15:
-                return "OnKeyUpTrigger";
-            case 16:
-                return "OnPickOutTrigger";
-            default:
-                return "";
-        }
-    }
-}
-/**
- * Nothing
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.NothingTrigger = 0;
-/**
- * On pick
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnPickTrigger = 1;
-/**
- * On left pick
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnLeftPickTrigger = 2;
-/**
- * On right pick
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnRightPickTrigger = 3;
-/**
- * On center pick
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnCenterPickTrigger = 4;
-/**
- * On pick down
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnPickDownTrigger = 5;
-/**
- * On double pick
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnDoublePickTrigger = 6;
-/**
- * On pick up
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnPickUpTrigger = 7;
-/**
- * On pick out.
- * This trigger will only be raised if you also declared a OnPickDown
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnPickOutTrigger = 16;
-/**
- * On long press
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnLongPressTrigger = 8;
-/**
- * On pointer over
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnPointerOverTrigger = 9;
-/**
- * On pointer out
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnPointerOutTrigger = 10;
-/**
- * On every frame
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnEveryFrameTrigger = 11;
-/**
- * On intersection enter
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnIntersectionEnterTrigger = 12;
-/**
- * On intersection exit
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnIntersectionExitTrigger = 13;
-/**
- * On key down
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnKeyDownTrigger = 14;
-/**
- * On key up
- * @see https://doc.babylonjs.com/features/featuresDeepDive/events/actions#triggers
- */
-ActionManager.OnKeyUpTrigger = 15;
-
-/**
- * Map animation groups to ModelAnimation objects.
- * @param groups Animation groups to map.
- * @param namePrefix Optional prefix to remove from animation names.
- * @returns Mapped animation objects.
- */
-function mapAnimationGroups(groups, namePrefix = '') {
-    return groups.map((group) => {
-        return {
-            name: group.name.substring(namePrefix.length),
-            loop: group.loopAnimation,
-            to: group.to,
-            from: group.from,
-        };
-    });
-}
-class ModelContainerImpl {
-    constructor(options) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.metadata = new Map();
-        this.materialSelectedObservable = new Observable();
-        this.materialDeselectedObservable = new Observable();
-        this.materialVariantObservable = new Observable();
-        this.modelVariantObservable = new Observable();
-        /**
-         * A map of callbacks for material changes that should run when the scene has loaded.
-         * [materialName, [variantKey, callback]]
-         */
-        this.materialReadyToLoadCallbacks = new Map();
-        /**
-         * A map of callbacks for model changes that should run when the scene has loaded.
-         * [variantKey, callback]
-         */
-        this.modelReadyToLoadCallbacks = new Map();
-        /**
-         * A set of dynamic textures linked to workflow canvases, these textures
-         * update themselves when changes are made to the underlying canvas
-         */
-        this.dynamicTextures = new Map();
-        /**
-         * Queued material changes that should be applied when the current change is done.
-         */
-        this.queuedMaterialChanges = new Map();
-        /**
-         * Material changes that are currently being applied.
-         */
-        this.materialChangesInProgress = [];
-        /**
-         * Queued model changes that should be applied when the current change is done.
-         */
-        this.queuedModelChanges = new Map();
-        /**
-         * Model changes that are currently being applied.
-         */
-        this.modelChangesInProgress = [];
-        this.animations = [];
-        this.initialized = false;
-        this.materials = [];
-        const { enablePicking, modelDetails, previewService, progressHandler, scene, } = options;
-        this.enablePicking = enablePicking;
-        this.contextService = modelDetails.contextService;
-        this.id = generateGuid();
-        this.previewService = previewService;
-        this.scene = scene;
-        this.variantManager = new VariantManager(scene, this.renameClonedAsset.bind(this), this.setEnabled.bind(this));
-        this.previewService.registerInitializedListener(() => __awaiter(this, void 0, void 0, function* () { return yield this.processQueuedEvents(); }));
-        this.transformRoot = new TransformNode('root', this.scene);
-        const importModel = () => __awaiter(this, void 0, void 0, function* () {
-            this.assetContainer = yield getAssetContainer(modelDetails.model, scene, progressHandler);
-            this.initialized = true;
-            this.instantiate();
-            return this;
-        });
-        this.importPromise = importModel();
-    }
-    //#region Interface implementation
-    applyMaterialVariant(targetMaterial, key, material, removeWhenUndefined) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // If the scene hasn't finished loading yet, let's queue the material changes
-            // up to have them play back when the scene is ready. NOTE: We queue using
-            // option as a key, this prevents multiple options applying and making eachothers changes redundant.
-            if (this.previewService.getSceneInitializationProgress() !== 100 ||
-                !this.initialized) {
-                if (this.materialReadyToLoadCallbacks.has(targetMaterial)) {
-                    const entry = this.materialReadyToLoadCallbacks.get(targetMaterial);
-                    entry === null || entry === void 0 ? void 0 : entry.set(key, this.applyMaterialVariant.bind(this, targetMaterial, key, material, removeWhenUndefined));
-                }
-                else {
-                    this.materialReadyToLoadCallbacks.set(targetMaterial, new Map());
-                    const newEntry = this.materialReadyToLoadCallbacks.get(targetMaterial);
-                    newEntry === null || newEntry === void 0 ? void 0 : newEntry.set(key, this.applyMaterialVariant.bind(this, targetMaterial, key, material, removeWhenUndefined));
-                }
-                return;
-            }
-            const applyChange = () => __awaiter(this, void 0, void 0, function* () {
-                yield this.variantManager.applyMaterial(targetMaterial, material, (remainingCount, totalCount, taskName) => {
-                    this.materialVariantObservable.notifyObservers({
-                        remainingCount,
-                        totalCount,
-                        taskName,
-                    });
-                }, removeWhenUndefined);
-            });
-            // If the material is already being changed, let's queue the change up
-            if (this.materialChangesInProgress.includes(targetMaterial)) {
-                if (this.queuedMaterialChanges.has(targetMaterial)) {
-                    const entry = this.queuedMaterialChanges.get(targetMaterial);
-                    entry === null || entry === void 0 ? void 0 : entry.set(key, applyChange);
-                }
-                else {
-                    this.queuedMaterialChanges.set(targetMaterial, new Map());
-                    const newEntry = this.queuedMaterialChanges.get(targetMaterial);
-                    newEntry === null || newEntry === void 0 ? void 0 : newEntry.set(key, applyChange);
-                }
-                return;
-            }
-            // Add the change to the in progress list and apply it.
-            this.materialChangesInProgress.push(targetMaterial);
-            yield applyChange();
-            // Apply any queued changes for this material.
-            if (this.queuedMaterialChanges.has(targetMaterial)) {
-                const entry = this.queuedMaterialChanges.get(targetMaterial);
-                entry.forEach((queuedChange) => __awaiter(this, void 0, void 0, function* () {
-                    yield queuedChange();
-                }));
-                this.queuedMaterialChanges.delete(targetMaterial);
-            }
-            this.materialChangesInProgress.splice(this.materialChangesInProgress.indexOf(targetMaterial), 1);
-            this.configureGlowLayer();
-        });
-    }
-    applyModelVariant(key, modelDetails, replaceProductModel) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // If the scene hasn't finished loading yet, let's queue the model changes
-            // up to have them play back when the scene is ready.
-            if (!this.previewService.getIsInitialized() || !this.initialized) {
-                this.modelReadyToLoadCallbacks.set(key, this.applyModelVariant.bind(this, key, modelDetails, replaceProductModel));
-                return;
-            }
-            const createInstance = () => {
-                return this.variantManager.applyModel(key, replaceProductModel, modelDetails === null || modelDetails === void 0 ? void 0 : modelDetails.model, (eventData) => {
-                    this.modelVariantObservable.notifyObservers(Object.assign(Object.assign({}, eventData), { key }));
-                });
-            };
-            // If the model is already being changed, let's queue the change up
-            if (this.modelChangesInProgress.includes(key)) {
-                this.queuedModelChanges.set(key, createInstance);
-                return;
-            }
-            // Model variant changes override each other, so
-            // we need to make sure we're always using the latest one.
-            const getLatestInstance = () => __awaiter(this, void 0, void 0, function* () {
-                this.modelChangesInProgress.push(key);
-                let instance = yield createInstance();
-                // Apply any queued changes
-                if (this.queuedModelChanges.has(key)) {
-                    const queuedChange = this.queuedModelChanges.get(key);
-                    instance = yield queuedChange();
-                    this.queuedModelChanges.delete(key);
-                }
-                this.modelChangesInProgress.splice(this.modelChangesInProgress.indexOf(key), 1);
-                return instance;
-            });
-            // Add the change to the in progress list and apply it.
-            const createdInstance = yield getLatestInstance();
-            this.modelInstance &&
-                resetAnimationGroups(this.modelInstance.animationGroups);
-            if (!this.contextService) {
-                this.contextService = modelDetails === null || modelDetails === void 0 ? void 0 : modelDetails.contextService;
-            }
-            if (createdInstance) {
-                // Configure the model instance
-                this.configureModelInstance(createdInstance);
-            }
-            else {
-                this.configureGlowLayer();
-            }
-        });
-    }
-    dispose() {
-        var _a;
-        this.destroyInstance();
-        this.variantManager.dispose();
-        this.dynamicTextures.forEach((texture) => texture === null || texture === void 0 ? void 0 : texture.dispose());
-        this.dynamicTextures.clear();
-        this.materials.forEach((material) => material && (material === null || material === void 0 ? void 0 : material.dispose()));
-        this.materials = [];
-        (_a = this.transformRoot) === null || _a === void 0 ? void 0 : _a.dispose();
-        this.transformRoot = undefined;
-        this.previewService.modelUnloaded(this);
-    }
-    executeAnimation(animation) {
-        if (!this.previewService.getIsInitialized()) {
-            this.queuedModelAnimation = animation;
-            return;
-        }
-        if (!this.modelInstance)
-            return;
-        executeAnimationGroups([
-            ...this.modelInstance.animationGroups,
-            ...this.variantManager.getAnimationGroups(),
-        ], animation.loop, animation.to, animation.from, animation.name ? this.renameClonedAsset(animation.name) : undefined);
-    }
-    getAnimations(includeVariants) {
-        return [
-            ...this.animations,
-            ...(includeVariants
-                ? mapAnimationGroups(this.variantManager.getAnimationGroups(), this.renameClonedAsset(''))
-                : []),
-        ];
-    }
-    getId() {
-        return this.id;
-    }
-    listMaterials() {
-        var _a;
-        const materials = (_a = this.scene) === null || _a === void 0 ? void 0 : _a.materials.filter((mat) => mat.name.startsWith(this.id));
-        if (!materials) {
-            return [];
-        }
-        return materials.map((material) => {
-            return {
-                id: material.id,
-                name: this.stripIdFromName(material.name),
-            };
-        });
-    }
-    registerMaterialSelectedCallback(callback) {
-        this.materialSelectedObservable.add(callback);
-    }
-    unregisterMaterialSelectedCallback(callback) {
-        this.materialSelectedObservable.removeCallback(callback);
-    }
-    registerMaterialDeselectedCallback(callback) {
-        this.materialDeselectedObservable.add(callback);
-    }
-    unregisterMaterialDeselectedCallback(callback) {
-        this.materialDeselectedObservable.removeCallback(callback);
-    }
-    get position() {
-        return this.transformRoot.position;
-    }
-    set position(value) {
-        this.transformRoot.position = new Vector3(value.x, value.y, value.z);
-    }
-    get rotation() {
-        return this.transformRoot.rotation;
-    }
-    set rotation(value) {
-        this.transformRoot.rotation = new Vector3(value.x, value.y, value.z);
-    }
-    get scale() {
-        return this.transformRoot.scaling;
-    }
-    set scale(value) {
-        this.transformRoot.scaling = new Vector3(value.x, value.y, value.z);
-    }
-    //#endregion
-    //#region Custom implementation functions
-    attachPickingHandler(model) {
-        model.rootNodes.forEach((node) => {
-            node.getChildMeshes(false).forEach((m) => {
-                if (m.name === 'targetcube_t' || m.name === 'backgroundShell') {
-                    return;
-                }
-                if (!m.actionManager) {
-                    m.actionManager = new ActionManager(this.scene);
-                }
-                m.actionManager.registerAction(new ExecuteCodeAction(ActionManager.OnPointerOverTrigger, (e) => {
-                    if (e.meshUnderPointer) {
-                        if (m.material) {
-                            this.materialSelectedObservable.notifyObservers({
-                                id: m.material.id,
-                                name: this.stripIdFromName(m.material.name),
-                            });
-                        }
-                    }
-                }));
-                m.actionManager.registerAction(new ExecuteCodeAction(ActionManager.OnPointerOutTrigger, () => {
-                    if (m.material) {
-                        this.materialDeselectedObservable.notifyObservers({
-                            id: m.material.id,
-                            name: this.stripIdFromName(m.material.name),
-                        });
-                    }
-                }));
-            });
-        });
-    }
-    /**
-     * Returns a promise which resolves when the model has been initialized.
-     */
-    getInitializationPromise() {
-        return this.importPromise;
-    }
-    /**
-     * Returns true if the model has been initialized.
-     */
-    getIsInitialized() {
-        return this.initialized;
-    }
-    getQueuedMaterialVariantCount() {
-        return this.materialReadyToLoadCallbacks.size;
-    }
-    getQueuedModelVariantCount() {
-        return this.modelReadyToLoadCallbacks.size;
-    }
-    configureGlowLayer() {
-        // Enable glow layer if any materials use emission.
-        const matPredicate = (mat) => mat instanceof PBRMaterial && mat.emissiveTexture !== null;
-        const shouldEnableGlow = this.materials.some(matPredicate) ||
-            this.variantManager.getAllMaterials().some(matPredicate);
-        if (shouldEnableGlow) {
-            this.previewService
-                .getGlowLayerManager()
-                .includeMeshes(this.getAllMeshes());
-        }
-        else {
-            this.previewService
-                .getGlowLayerManager()
-                .removeMeshes(this.getAllMeshes());
-        }
-    }
-    configureModelInstance(modelInstance) {
-        var _a;
-        // Reset transform point
-        const position = this.transformRoot.position;
-        const rotation = this.transformRoot.rotation;
-        const scale = this.transformRoot.scaling;
-        this.transformRoot.position = Vector3.Zero();
-        this.transformRoot.rotation = Vector3.Zero();
-        this.transformRoot.scaling = Vector3.One();
-        // Move the model to the transform root
-        modelInstance.rootNodes.forEach((node) => {
-            node.parent = this.transformRoot;
-        });
-        // Return the transform values
-        this.transformRoot.position = position;
-        this.transformRoot.rotation = rotation;
-        this.transformRoot.scaling = scale;
-        // Create & apply dynamic textures
-        this.canvasPanels = ((_a = this.contextService) === null || _a === void 0 ? void 0 : _a.getAll()) || new Map();
-        attachDynamicTextures(this.materials.concat(this.variantManager.getAllMaterials()), this.scene, this.canvasPanels, this.dynamicTextures, `${this.id}_`);
-        // Register picking handler for the new instance
-        if (this.enablePicking) {
-            this.attachPickingHandler(modelInstance);
-        }
-        this.configureGlowLayer();
-    }
-    /**
-     * Destroys the model instance.
-     */
-    destroyInstance() {
-        var _a;
-        (_a = this.modelInstance) === null || _a === void 0 ? void 0 : _a.dispose();
-        this.modelInstance = undefined;
-    }
-    getAllMeshes() {
-        var _a;
-        return (_a = this.modelInstance) === null || _a === void 0 ? void 0 : _a.rootNodes.map((node) => node.getChildMeshes(false).filter((m) => m instanceof Mesh)).flat();
-    }
-    instantiate() {
-        this.modelInstance = this.assetContainer.instantiateModelsToScene(this.renameClonedAsset.bind(this), true);
-        // Store the materials used by the model
-        this.materials = getAllMaterialsForInstance(this.modelInstance);
-        // Configure the new model instance
-        this.configureModelInstance(this.modelInstance);
-        this.animations = mapAnimationGroups(this.modelInstance.animationGroups, this.renameClonedAsset(''));
-        // Potentially process any queued events
-        // this will do nothing if the scene is not ready
-        this.processQueuedEvents();
-    }
-    renameClonedAsset(name) {
-        return `${this.id}_${name}`;
-    }
-    setEnabled(enabled) {
-        if (enabled && !this.modelInstance) {
-            this.instantiate();
-        }
-        else if (!enabled && this.modelInstance) {
-            this.destroyInstance();
-        }
-    }
-    updateDynamicTextures() {
-        var _a;
-        // Update dynamic textures where canvas changes have been made.
-        (_a = this.canvasPanels) === null || _a === void 0 ? void 0 : _a.forEach((canvasPanel, layoutKey) => {
-            const dynamicTexture = this.dynamicTextures.get(layoutKey);
-            if (dynamicTexture &&
-                canvasPanel.getStaticContextDirty() &&
-                dynamicTexture.isReady()) {
-                dynamicTexture.update(false);
-                canvasPanel.setStaticContextDirty(false);
-            }
-        });
-    }
-    //#region Listeners
-    registerMaterialVariantListener(listener) {
-        this.materialVariantObservable.add(listener);
-    }
-    unregisterMaterialVariantListener(listener) {
-        this.materialVariantObservable.removeCallback(listener);
-    }
-    registerModelVariantListener(listener) {
-        this.modelVariantObservable.add(listener);
-    }
-    unregisterModelVariantListener(listener) {
-        this.modelVariantObservable.removeCallback(listener);
-    }
-    //#endregion
-    stripIdFromName(name) {
-        return name.substring(this.id.length + 1);
-    }
-    processQueuedEvents() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.previewService.getIsInitialized()) {
-                return;
-            }
-            yield Promise.all(Array.from(this.materialReadyToLoadCallbacks.values()).map((callbacks) => Array.from(callbacks.values()).map((callback) => callback())));
-            this.materialReadyToLoadCallbacks.clear();
-            yield Promise.all(Array.from(this.modelReadyToLoadCallbacks.values()).map((callback) => callback()));
-            this.modelReadyToLoadCallbacks.clear();
-            if (this.queuedModelAnimation) {
-                this.executeAnimation(this.queuedModelAnimation);
-                this.queuedModelAnimation = undefined;
-            }
-        });
-    }
-}
-
-export { ModelContainerImpl };