@spiffcommerce/preview 3.6.2-rc.4 → 3.6.2-rc.5

package/dist/node_modules/@babylonjs/core/Misc/typeStore.esm.js

@@ -0,0 +1,11 @@
+const s = {};
+function n(e, t) {
+  s[e] = t;
+}
+function r(e) {
+  return s[e];
+}
+export {
+  r as GetClass,
+  n as RegisterClass
+};

package/dist/node_modules/@babylonjs/core/Misc/uniqueIdGenerator.esm.js

@@ -0,0 +1,13 @@
+class t {
+  /**
+   * Gets an unique (relatively to the current scene) Id
+   */
+  static get UniqueId() {
+    const e = this._UniqueIdCounter;
+    return this._UniqueIdCounter++, e;
+  }
+}
+t._UniqueIdCounter = 1;
+export {
+  t as UniqueIdGenerator
+};

package/dist/node_modules/@babylonjs/core/Misc/webRequest.esm.js

@@ -0,0 +1,135 @@
+function i() {
+  return typeof _native < "u" && _native.XMLHttpRequest ? new _native.XMLHttpRequest() : new XMLHttpRequest();
+}
+class s {
+  constructor() {
+    this._xhr = i(), this._requestURL = "";
+  }
+  _injectCustomRequestHeaders() {
+    if (!this._shouldSkipRequestModifications(this._requestURL))
+      for (const e in s.CustomRequestHeaders) {
+        const t = s.CustomRequestHeaders[e];
+        t && this._xhr.setRequestHeader(e, t);
+      }
+  }
+  _shouldSkipRequestModifications(e) {
+    return s.SkipRequestModificationForBabylonCDN && (e.includes("preview.babylonjs.com") || e.includes("cdn.babylonjs.com"));
+  }
+  /**
+   * Gets or sets a function to be called when loading progress changes
+   */
+  get onprogress() {
+    return this._xhr.onprogress;
+  }
+  set onprogress(e) {
+    this._xhr.onprogress = e;
+  }
+  /**
+   * Returns client's state
+   */
+  get readyState() {
+    return this._xhr.readyState;
+  }
+  /**
+   * Returns client's status
+   */
+  get status() {
+    return this._xhr.status;
+  }
+  /**
+   * Returns client's status as a text
+   */
+  get statusText() {
+    return this._xhr.statusText;
+  }
+  /**
+   * Returns client's response
+   */
+  get response() {
+    return this._xhr.response;
+  }
+  /**
+   * Returns client's response url
+   */
+  get responseURL() {
+    return this._xhr.responseURL;
+  }
+  /**
+   * Returns client's response as text
+   */
+  get responseText() {
+    return this._xhr.responseText;
+  }
+  /**
+   * Gets or sets the expected response type
+   */
+  get responseType() {
+    return this._xhr.responseType;
+  }
+  set responseType(e) {
+    this._xhr.responseType = e;
+  }
+  /**
+   * Gets or sets the timeout value in milliseconds
+   */
+  get timeout() {
+    return this._xhr.timeout;
+  }
+  set timeout(e) {
+    this._xhr.timeout = e;
+  }
+  addEventListener(e, t, r) {
+    this._xhr.addEventListener(e, t, r);
+  }
+  removeEventListener(e, t, r) {
+    this._xhr.removeEventListener(e, t, r);
+  }
+  /**
+   * Cancels any network activity
+   */
+  abort() {
+    this._xhr.abort();
+  }
+  /**
+   * Initiates the request. The optional argument provides the request body. The argument is ignored if request method is GET or HEAD
+   * @param body defines an optional request body
+   */
+  send(e) {
+    s.CustomRequestHeaders && this._injectCustomRequestHeaders(), this._xhr.send(e);
+  }
+  /**
+   * Sets the request method, request URL
+   * @param method defines the method to use (GET, POST, etc..)
+   * @param url defines the url to connect with
+   */
+  open(e, t) {
+    for (const r of s.CustomRequestModifiers) {
+      if (this._shouldSkipRequestModifications(t))
+        return;
+      r(this._xhr, t);
+    }
+    return t = t.replace("file:http:", "http:"), t = t.replace("file:https:", "https:"), this._requestURL = t, this._xhr.open(e, t, !0);
+  }
+  /**
+   * Sets the value of a request header.
+   * @param name The name of the header whose value is to be set
+   * @param value The value to set as the body of the header
+   */
+  setRequestHeader(e, t) {
+    this._xhr.setRequestHeader(e, t);
+  }
+  /**
+   * Get the string containing the text of a particular header's value.
+   * @param name The name of the header
+   * @returns The string containing the text of the given header name
+   */
+  getResponseHeader(e) {
+    return this._xhr.getResponseHeader(e);
+  }
+}
+s.CustomRequestHeaders = {};
+s.CustomRequestModifiers = new Array();
+s.SkipRequestModificationForBabylonCDN = !0;
+export {
+  s as WebRequest
+};

package/dist/node_modules/@babylonjs/core/Misc/workerPool.esm.js

@@ -0,0 +1,80 @@
+class h {
+  /**
+   * Constructor
+   * @param workers Array of workers to use for actions
+   */
+  constructor(e) {
+    this._pendingActions = new Array(), this._workerInfos = e.map((s) => ({
+      workerPromise: Promise.resolve(s),
+      idle: !0
+    }));
+  }
+  /**
+   * Terminates all workers and clears any pending actions.
+   */
+  dispose() {
+    for (const e of this._workerInfos)
+      e.workerPromise.then((s) => {
+        s.terminate();
+      });
+    this._workerInfos.length = 0, this._pendingActions.length = 0;
+  }
+  /**
+   * Pushes an action to the worker pool. If all the workers are active, the action will be
+   * pended until a worker has completed its action.
+   * @param action The action to perform. Call onComplete when the action is complete.
+   */
+  push(e) {
+    this._executeOnIdleWorker(e) || this._pendingActions.push(e);
+  }
+  _executeOnIdleWorker(e) {
+    for (const s of this._workerInfos)
+      if (s.idle)
+        return this._execute(s, e), !0;
+    return !1;
+  }
+  _execute(e, s) {
+    e.idle = !1, e.workerPromise.then((t) => {
+      s(t, () => {
+        const i = this._pendingActions.shift();
+        i ? this._execute(e, i) : e.idle = !0;
+      });
+    });
+  }
+}
+class r extends h {
+  constructor(e, s, t = r.DefaultOptions) {
+    super([]), this._maxWorkers = e, this._createWorkerAsync = s, this._options = t;
+  }
+  push(e) {
+    if (!this._executeOnIdleWorker(e))
+      if (this._workerInfos.length < this._maxWorkers) {
+        const s = {
+          workerPromise: this._createWorkerAsync(),
+          idle: !1
+        };
+        this._workerInfos.push(s), this._execute(s, e);
+      } else
+        this._pendingActions.push(e);
+  }
+  _execute(e, s) {
+    e.timeoutId && (clearTimeout(e.timeoutId), delete e.timeoutId), super._execute(e, (t, i) => {
+      s(t, () => {
+        i(), e.idle && (e.timeoutId = setTimeout(() => {
+          e.workerPromise.then((n) => {
+            n.terminate();
+          });
+          const o = this._workerInfos.indexOf(e);
+          o !== -1 && this._workerInfos.splice(o, 1);
+        }, this._options.idleTimeElapsedBeforeRelease));
+      });
+    });
+  }
+}
+r.DefaultOptions = {
+  idleTimeElapsedBeforeRelease: 1e3
+};
+export {
+  r as AutoReleaseWorkerPool,
+  h as WorkerPool
+};

package/dist/node_modules/@babylonjs/core/Morph/morphTarget.esm.js

@@ -0,0 +1,187 @@
+import { __decorate as l } from "../tslib.es6.esm.js";
+import { Observable as o } from "../Misc/observable.esm.js";
+import { EngineStore as d } from "../Engines/engineStore.esm.js";
+import { VertexBuffer as i } from "../Buffers/buffer.esm.js";
+import { serialize as m, SerializationHelper as h } from "../Misc/decorators.esm.js";
+import { GetClass as f } from "../Misc/typeStore.esm.js";
+class r {
+  /**
+   * Gets or sets the influence of this target (ie. its weight in the overall morphing)
+   */
+  get influence() {
+    return this._influence;
+  }
+  set influence(t) {
+    if (this._influence === t)
+      return;
+    const s = this._influence;
+    this._influence = t, this.onInfluenceChanged.hasObservers() && this.onInfluenceChanged.notifyObservers(s === 0 || t === 0);
+  }
+  /**
+   * Gets or sets the animation properties override
+   */
+  get animationPropertiesOverride() {
+    return !this._animationPropertiesOverride && this._scene ? this._scene.animationPropertiesOverride : this._animationPropertiesOverride;
+  }
+  set animationPropertiesOverride(t) {
+    this._animationPropertiesOverride = t;
+  }
+  /**
+   * Creates a new MorphTarget
+   * @param name defines the name of the target
+   * @param influence defines the influence to use
+   * @param scene defines the scene the morphtarget belongs to
+   */
+  constructor(t, s = 0, n = null) {
+    this.name = t, this.animations = new Array(), this._positions = null, this._normals = null, this._tangents = null, this._uvs = null, this._uniqueId = 0, this.onInfluenceChanged = new o(), this._onDataLayoutChanged = new o(), this._animationPropertiesOverride = null, this._scene = n || d.LastCreatedScene, this.influence = s, this._scene && (this._uniqueId = this._scene.getUniqueId());
+  }
+  /**
+   * Gets the unique ID of this manager
+   */
+  get uniqueId() {
+    return this._uniqueId;
+  }
+  /**
+   * Gets a boolean defining if the target contains position data
+   */
+  get hasPositions() {
+    return !!this._positions;
+  }
+  /**
+   * Gets a boolean defining if the target contains normal data
+   */
+  get hasNormals() {
+    return !!this._normals;
+  }
+  /**
+   * Gets a boolean defining if the target contains tangent data
+   */
+  get hasTangents() {
+    return !!this._tangents;
+  }
+  /**
+   * Gets a boolean defining if the target contains texture coordinates data
+   */
+  get hasUVs() {
+    return !!this._uvs;
+  }
+  /**
+   * Affects position data to this target
+   * @param data defines the position data to use
+   */
+  setPositions(t) {
+    const s = this.hasPositions;
+    this._positions = t, s !== this.hasPositions && this._onDataLayoutChanged.notifyObservers(void 0);
+  }
+  /**
+   * Gets the position data stored in this target
+   * @returns a FloatArray containing the position data (or null if not present)
+   */
+  getPositions() {
+    return this._positions;
+  }
+  /**
+   * Affects normal data to this target
+   * @param data defines the normal data to use
+   */
+  setNormals(t) {
+    const s = this.hasNormals;
+    this._normals = t, s !== this.hasNormals && this._onDataLayoutChanged.notifyObservers(void 0);
+  }
+  /**
+   * Gets the normal data stored in this target
+   * @returns a FloatArray containing the normal data (or null if not present)
+   */
+  getNormals() {
+    return this._normals;
+  }
+  /**
+   * Affects tangent data to this target
+   * @param data defines the tangent data to use
+   */
+  setTangents(t) {
+    const s = this.hasTangents;
+    this._tangents = t, s !== this.hasTangents && this._onDataLayoutChanged.notifyObservers(void 0);
+  }
+  /**
+   * Gets the tangent data stored in this target
+   * @returns a FloatArray containing the tangent data (or null if not present)
+   */
+  getTangents() {
+    return this._tangents;
+  }
+  /**
+   * Affects texture coordinates data to this target
+   * @param data defines the texture coordinates data to use
+   */
+  setUVs(t) {
+    const s = this.hasUVs;
+    this._uvs = t, s !== this.hasUVs && this._onDataLayoutChanged.notifyObservers(void 0);
+  }
+  /**
+   * Gets the texture coordinates data stored in this target
+   * @returns a FloatArray containing the texture coordinates data (or null if not present)
+   */
+  getUVs() {
+    return this._uvs;
+  }
+  /**
+   * Clone the current target
+   * @returns a new MorphTarget
+   */
+  clone() {
+    const t = h.Clone(() => new r(this.name, this.influence, this._scene), this);
+    return t._positions = this._positions, t._normals = this._normals, t._tangents = this._tangents, t._uvs = this._uvs, t;
+  }
+  /**
+   * Serializes the current target into a Serialization object
+   * @returns the serialized object
+   */
+  serialize() {
+    const t = {};
+    return t.name = this.name, t.influence = this.influence, t.positions = Array.prototype.slice.call(this.getPositions()), this.id != null && (t.id = this.id), this.hasNormals && (t.normals = Array.prototype.slice.call(this.getNormals())), this.hasTangents && (t.tangents = Array.prototype.slice.call(this.getTangents())), this.hasUVs && (t.uvs = Array.prototype.slice.call(this.getUVs())), h.AppendSerializedAnimations(this, t), t;
+  }
+  /**
+   * Returns the string "MorphTarget"
+   * @returns "MorphTarget"
+   */
+  getClassName() {
+    return "MorphTarget";
+  }
+  // Statics
+  /**
+   * Creates a new target from serialized data
+   * @param serializationObject defines the serialized data to use
+   * @param scene defines the hosting scene
+   * @returns a new MorphTarget
+   */
+  static Parse(t, s) {
+    const n = new r(t.name, t.influence);
+    if (n.setPositions(t.positions), t.id != null && (n.id = t.id), t.normals && n.setNormals(t.normals), t.tangents && n.setTangents(t.tangents), t.uvs && n.setUVs(t.uvs), t.animations) {
+      for (let e = 0; e < t.animations.length; e++) {
+        const u = t.animations[e], a = f("BABYLON.Animation");
+        a && n.animations.push(a.Parse(u));
+      }
+      t.autoAnimate && s && s.beginAnimation(n, t.autoAnimateFrom, t.autoAnimateTo, t.autoAnimateLoop, t.autoAnimateSpeed || 1);
+    }
+    return n;
+  }
+  /**
+   * Creates a MorphTarget from mesh data
+   * @param mesh defines the source mesh
+   * @param name defines the name to use for the new target
+   * @param influence defines the influence to attach to the target
+   * @returns a new MorphTarget
+   */
+  static FromMesh(t, s, n) {
+    s || (s = t.name);
+    const e = new r(s, n, t.getScene());
+    return e.setPositions(t.getVerticesData(i.PositionKind)), t.isVerticesDataPresent(i.NormalKind) && e.setNormals(t.getVerticesData(i.NormalKind)), t.isVerticesDataPresent(i.TangentKind) && e.setTangents(t.getVerticesData(i.TangentKind)), t.isVerticesDataPresent(i.UVKind) && e.setUVs(t.getVerticesData(i.UVKind)), e;
+  }
+}
+l([
+  m()
+], r.prototype, "id", void 0);
+export {
+  r as MorphTarget
+};

package/dist/node_modules/@babylonjs/core/Morph/morphTargetManager.esm.js

@@ -0,0 +1,249 @@
+import { SmartArray as l } from "../Misc/smartArray.esm.js";
+import { Logger as c } from "../Misc/logger.esm.js";
+import { EngineStore as T } from "../Engines/engineStore.esm.js";
+import { MorphTarget as x } from "./morphTarget.esm.js";
+import { RawTexture2DArray as f } from "../Materials/Textures/rawTexture2DArray.esm.js";
+class h {
+  /**
+   * Sets a boolean indicating that adding new target or updating an existing target will not update the underlying data buffers
+   */
+  set areUpdatesFrozen(t) {
+    t ? this._blockCounter++ : (this._blockCounter--, this._blockCounter <= 0 && (this._blockCounter = 0, this._syncActiveTargets(!0)));
+  }
+  get areUpdatesFrozen() {
+    return this._blockCounter > 0;
+  }
+  /**
+   * Creates a new MorphTargetManager
+   * @param scene defines the current scene
+   */
+  constructor(t = null) {
+    if (this._targets = new Array(), this._targetInfluenceChangedObservers = new Array(), this._targetDataLayoutChangedObservers = new Array(), this._activeTargets = new l(16), this._supportsNormals = !1, this._supportsTangents = !1, this._supportsUVs = !1, this._vertexCount = 0, this._textureVertexStride = 0, this._textureWidth = 0, this._textureHeight = 1, this._uniqueId = 0, this._tempInfluences = new Array(), this._canUseTextureForTargets = !1, this._blockCounter = 0, this._parentContainer = null, this.optimizeInfluencers = !0, this.enableNormalMorphing = !0, this.enableTangentMorphing = !0, this.enableUVMorphing = !0, this._useTextureToStoreTargets = !0, t || (t = T.LastCreatedScene), this._scene = t, this._scene) {
+      this._scene.addMorphTargetManager(this), this._uniqueId = this._scene.getUniqueId();
+      const e = this._scene.getEngine().getCaps();
+      this._canUseTextureForTargets = e.canUseGLVertexID && e.textureFloat && e.maxVertexTextureImageUnits > 0 && e.texture2DArrayMaxLayerCount > 1;
+    }
+  }
+  /**
+   * Gets the unique ID of this manager
+   */
+  get uniqueId() {
+    return this._uniqueId;
+  }
+  /**
+   * Gets the number of vertices handled by this manager
+   */
+  get vertexCount() {
+    return this._vertexCount;
+  }
+  /**
+   * Gets a boolean indicating if this manager supports morphing of normals
+   */
+  get supportsNormals() {
+    return this._supportsNormals && this.enableNormalMorphing;
+  }
+  /**
+   * Gets a boolean indicating if this manager supports morphing of tangents
+   */
+  get supportsTangents() {
+    return this._supportsTangents && this.enableTangentMorphing;
+  }
+  /**
+   * Gets a boolean indicating if this manager supports morphing of texture coordinates
+   */
+  get supportsUVs() {
+    return this._supportsUVs && this.enableUVMorphing;
+  }
+  /**
+   * Gets the number of targets stored in this manager
+   */
+  get numTargets() {
+    return this._targets.length;
+  }
+  /**
+   * Gets the number of influencers (ie. the number of targets with influences > 0)
+   */
+  get numInfluencers() {
+    return this._activeTargets.length;
+  }
+  /**
+   * Gets the list of influences (one per target)
+   */
+  get influences() {
+    return this._influences;
+  }
+  /**
+   * Gets or sets a boolean indicating that targets should be stored as a texture instead of using vertex attributes (default is true).
+   * Please note that this option is not available if the hardware does not support it
+   */
+  get useTextureToStoreTargets() {
+    return this._useTextureToStoreTargets;
+  }
+  set useTextureToStoreTargets(t) {
+    this._useTextureToStoreTargets = t;
+  }
+  /**
+   * Gets a boolean indicating that the targets are stored into a texture (instead of as attributes)
+   */
+  get isUsingTextureForTargets() {
+    var t;
+    return h.EnableTextureStorage && this.useTextureToStoreTargets && this._canUseTextureForTargets && !(!((t = this._scene) === null || t === void 0) && t.getEngine().getCaps().disableMorphTargetTexture);
+  }
+  /**
+   * Gets the active target at specified index. An active target is a target with an influence > 0
+   * @param index defines the index to check
+   * @returns the requested target
+   */
+  getActiveTarget(t) {
+    return this._activeTargets.data[t];
+  }
+  /**
+   * Gets the target at specified index
+   * @param index defines the index to check
+   * @returns the requested target
+   */
+  getTarget(t) {
+    return this._targets[t];
+  }
+  /**
+   * Add a new target to this manager
+   * @param target defines the target to add
+   */
+  addTarget(t) {
+    this._targets.push(t), this._targetInfluenceChangedObservers.push(t.onInfluenceChanged.add((e) => {
+      this._syncActiveTargets(e);
+    })), this._targetDataLayoutChangedObservers.push(t._onDataLayoutChanged.add(() => {
+      this._syncActiveTargets(!0);
+    })), this._syncActiveTargets(!0);
+  }
+  /**
+   * Removes a target from the manager
+   * @param target defines the target to remove
+   */
+  removeTarget(t) {
+    const e = this._targets.indexOf(t);
+    e >= 0 && (this._targets.splice(e, 1), t.onInfluenceChanged.remove(this._targetInfluenceChangedObservers.splice(e, 1)[0]), t._onDataLayoutChanged.remove(this._targetDataLayoutChangedObservers.splice(e, 1)[0]), this._syncActiveTargets(!0)), this._scene && this._scene.stopAnimation(t);
+  }
+  /**
+   * @internal
+   */
+  _bind(t) {
+    t.setFloat3("morphTargetTextureInfo", this._textureVertexStride, this._textureWidth, this._textureHeight), t.setFloatArray("morphTargetTextureIndices", this._morphTargetTextureIndices), t.setTexture("morphTargets", this._targetStoreTexture);
+  }
+  /**
+   * Clone the current manager
+   * @returns a new MorphTargetManager
+   */
+  clone() {
+    const t = new h(this._scene);
+    for (const e of this._targets)
+      t.addTarget(e.clone());
+    return t.enableNormalMorphing = this.enableNormalMorphing, t.enableTangentMorphing = this.enableTangentMorphing, t.enableUVMorphing = this.enableUVMorphing, t;
+  }
+  /**
+   * Serializes the current manager into a Serialization object
+   * @returns the serialized object
+   */
+  serialize() {
+    const t = {};
+    t.id = this.uniqueId, t.targets = [];
+    for (const e of this._targets)
+      t.targets.push(e.serialize());
+    return t;
+  }
+  _syncActiveTargets(t) {
+    if (this.areUpdatesFrozen)
+      return;
+    let e = 0;
+    this._activeTargets.reset(), this._supportsNormals = !0, this._supportsTangents = !0, this._supportsUVs = !0, this._vertexCount = 0, this._scene && this._targets.length > this._scene.getEngine().getCaps().texture2DArrayMaxLayerCount && (this.useTextureToStoreTargets = !1), (!this._morphTargetTextureIndices || this._morphTargetTextureIndices.length !== this._targets.length) && (this._morphTargetTextureIndices = new Float32Array(this._targets.length));
+    let i = -1;
+    for (const s of this._targets) {
+      if (i++, s.influence === 0 && this.optimizeInfluencers)
+        continue;
+      if (this._activeTargets.length >= h.MaxActiveMorphTargetsInVertexAttributeMode && !this.isUsingTextureForTargets)
+        break;
+      this._activeTargets.push(s), this._morphTargetTextureIndices[e] = i, this._tempInfluences[e++] = s.influence, this._supportsNormals = this._supportsNormals && s.hasNormals, this._supportsTangents = this._supportsTangents && s.hasTangents, this._supportsUVs = this._supportsUVs && s.hasUVs;
+      const r = s.getPositions();
+      if (r) {
+        const a = r.length / 3;
+        if (this._vertexCount === 0)
+          this._vertexCount = a;
+        else if (this._vertexCount !== a) {
+          c.Error("Incompatible target. Targets must all have the same vertices count.");
+          return;
+        }
+      }
+    }
+    this._morphTargetTextureIndices.length !== e && (this._morphTargetTextureIndices = this._morphTargetTextureIndices.slice(0, e)), (!this._influences || this._influences.length !== e) && (this._influences = new Float32Array(e));
+    for (let s = 0; s < e; s++)
+      this._influences[s] = this._tempInfluences[s];
+    t && this.synchronize();
+  }
+  /**
+   * Synchronize the targets with all the meshes using this morph target manager
+   */
+  synchronize() {
+    if (!(!this._scene || this.areUpdatesFrozen)) {
+      if (this.isUsingTextureForTargets && this._vertexCount) {
+        this._textureVertexStride = 1, this._supportsNormals && this._textureVertexStride++, this._supportsTangents && this._textureVertexStride++, this._supportsUVs && this._textureVertexStride++, this._textureWidth = this._vertexCount * this._textureVertexStride, this._textureHeight = 1;
+        const t = this._scene.getEngine().getCaps().maxTextureSize;
+        this._textureWidth > t && (this._textureHeight = Math.ceil(this._textureWidth / t), this._textureWidth = t);
+        let e = !0;
+        if (this._targetStoreTexture) {
+          const i = this._targetStoreTexture.getSize();
+          i.width === this._textureWidth && i.height === this._textureHeight && this._targetStoreTexture.depth === this._targets.length && (e = !1);
+        }
+        if (e) {
+          this._targetStoreTexture && this._targetStoreTexture.dispose();
+          const i = this._targets.length, s = new Float32Array(i * this._textureWidth * this._textureHeight * 4);
+          let r = 0;
+          for (let a = 0; a < i; a++) {
+            const o = this._targets[a], u = o.getPositions(), g = o.getNormals(), p = o.getUVs(), _ = o.getTangents();
+            if (!u) {
+              a === 0 && c.Error("Invalid morph target. Target must have positions.");
+              return;
+            }
+            r = a * this._textureWidth * this._textureHeight * 4;
+            for (let n = 0; n < this._vertexCount; n++)
+              s[r] = u[n * 3], s[r + 1] = u[n * 3 + 1], s[r + 2] = u[n * 3 + 2], r += 4, this._supportsNormals && g && (s[r] = g[n * 3], s[r + 1] = g[n * 3 + 1], s[r + 2] = g[n * 3 + 2], r += 4), this._supportsUVs && p && (s[r] = p[n * 2], s[r + 1] = p[n * 2 + 1], r += 4), this._supportsTangents && _ && (s[r] = _[n * 3], s[r + 1] = _[n * 3 + 1], s[r + 2] = _[n * 3 + 2], r += 4);
+          }
+          this._targetStoreTexture = f.CreateRGBATexture(s, this._textureWidth, this._textureHeight, i, this._scene, !1, !1, 1, 1);
+        }
+      }
+      for (const t of this._scene.meshes)
+        t.morphTargetManager === this && t._syncGeometryWithMorphTargetManager();
+    }
+  }
+  /**
+   * Release all resources
+   */
+  dispose() {
+    if (this._targetStoreTexture && this._targetStoreTexture.dispose(), this._targetStoreTexture = null, this._scene) {
+      if (this._scene.removeMorphTargetManager(this), this._parentContainer) {
+        const t = this._parentContainer.morphTargetManagers.indexOf(this);
+        t > -1 && this._parentContainer.morphTargetManagers.splice(t, 1), this._parentContainer = null;
+      }
+      for (const t of this._targets)
+        this._scene.stopAnimation(t);
+    }
+  }
+  // Statics
+  /**
+   * Creates a new MorphTargetManager from serialized data
+   * @param serializationObject defines the serialized data
+   * @param scene defines the hosting scene
+   * @returns the new MorphTargetManager
+   */
+  static Parse(t, e) {
+    const i = new h(e);
+    i._uniqueId = t.id;
+    for (const s of t.targets)
+      i.addTarget(x.Parse(s, e));
+    return i;
+  }
+}
+h.EnableTextureStorage = !0;
+h.MaxActiveMorphTargetsInVertexAttributeMode = 8;
+export {
+  h as MorphTargetManager
+};