@galacean/effects-core 2.0.0-alpha.26 → 2.0.0-alpha.27

package/dist/index.js

@@ -3,7 +3,7 @@
  * Description: Galacean Effects runtime core for the web
  * Author: Ant Group CO., Ltd.
  * Contributors: 燃然,飂兮,十弦,云垣,茂安,意绮
- * Version: v2.0.0-alpha.26
+ * Version: v2.0.0-alpha.27
  */
 
 'use strict';
@@ -4001,13 +4001,29 @@ var RenderFace;
     RenderFace["Front"] = "Front";
 })(RenderFace || (RenderFace = {}));
 
-var END_BEHAVIOR_DESTROY = 0;
-var END_BEHAVIOR_PAUSE = 1;
-var END_BEHAVIOR_FORWARD = 2;
-var END_BEHAVIOR_PAUSE_AND_DESTROY = 3;
-var END_BEHAVIOR_FREEZE = 4;
-var END_BEHAVIOR_RESTART = 5;
-var END_BEHAVIOR_DESTROY_CHILDREN = 6;
+/**
+ * 销毁
+ */ var END_BEHAVIOR_DESTROY = 0;
+/**
+ * 暂停
+ * @deprecated since 2.0 - use `END_BEHAVIOR_FREEZE` instead
+ */ var END_BEHAVIOR_PAUSE = 1;
+/**
+ * 无限播放
+ */ var END_BEHAVIOR_FORWARD = 2;
+/**
+ * 销毁并保留最后一帧
+ * @deprecated since 2.0
+ */ var END_BEHAVIOR_PAUSE_AND_DESTROY = 3;
+/**
+ * 冻结
+ */ var END_BEHAVIOR_FREEZE = 4;
+/**
+ * 重播
+ */ var END_BEHAVIOR_RESTART = 5;
+/**
+ *
+ */ var END_BEHAVIOR_DESTROY_CHILDREN = 6;
 var CAMERA_CLIP_MODE_VERTICAL = 1;
 var CAMERA_CLIP_MODE_NORMAL = 0;
 var MESSAGE_ITEM_PHRASE_BEGIN = 2;
@@ -4022,29 +4038,6 @@ var CameraClipMode;
      * 剪裁左右
      */ CameraClipMode[CameraClipMode["landscape"] = 0] = "landscape";
 })(CameraClipMode || (CameraClipMode = {}));
-/**
- * 结束行为
- */ var CompositionEndBehavior;
-(function(CompositionEndBehavior) {
-    /**
-     * 销毁
-     */ CompositionEndBehavior[CompositionEndBehavior["destroy"] = 0] = "destroy";
-    /**
-     * 暂停
-     */ CompositionEndBehavior[CompositionEndBehavior["pause"] = 1] = "pause";
-    /**
-     * 重播
-     */ CompositionEndBehavior[CompositionEndBehavior["restart"] = 5] = "restart";
-    /**
-     * 无限播放
-     */ CompositionEndBehavior[CompositionEndBehavior["forward"] = 2] = "forward";
-    /**
-     * 销毁并保留最后一帧
-     */ CompositionEndBehavior[CompositionEndBehavior["pause_destroy"] = 3] = "pause_destroy";
-    /**
-     * 冻结
-     */ CompositionEndBehavior[CompositionEndBehavior["freeze"] = 4] = "freeze";
-})(CompositionEndBehavior || (CompositionEndBehavior = {}));
 
 /**
  * 动态换图类型
@@ -4125,12 +4118,23 @@ var CameraClipMode;
     BezierKeyframeType[BezierKeyframeType["LINE_OUT"] = 6] = "LINE_OUT";
 })(BezierKeyframeType || (BezierKeyframeType = {}));
 
-var ItemEndBehavior;
-(function(ItemEndBehavior) {
-    ItemEndBehavior[ItemEndBehavior["destroy"] = 0] = "destroy";
-    ItemEndBehavior[ItemEndBehavior["loop"] = 5] = "loop";
-    ItemEndBehavior[ItemEndBehavior["freeze"] = 4] = "freeze";
-})(ItemEndBehavior || (ItemEndBehavior = {}));
+/**
+ * 结束行为
+ */ var EndBehavior;
+(function(EndBehavior) {
+    /**
+     * 销毁
+     */ EndBehavior[EndBehavior["destroy"] = 0] = "destroy";
+    /**
+     * 重播
+     */ EndBehavior[EndBehavior["restart"] = 5] = "restart";
+    /**
+     * 无限播放
+     */ EndBehavior[EndBehavior["forward"] = 2] = "forward";
+    /**
+     * 冻结
+     */ EndBehavior[EndBehavior["freeze"] = 4] = "freeze";
+})(EndBehavior || (EndBehavior = {}));
 var ParentItemEndBehavior;
 (function(ParentItemEndBehavior) {
     ParentItemEndBehavior[ParentItemEndBehavior["destroyChildren"] = 6] = "destroyChildren";
@@ -4455,7 +4459,6 @@ var index$1 = /*#__PURE__*/Object.freeze({
     get RenderType () { return RenderType; },
     get RenderFace () { return RenderFace; },
     get CameraClipMode () { return CameraClipMode; },
-    get CompositionEndBehavior () { return CompositionEndBehavior; },
     get BackgroundType () { return BackgroundType; },
     END_BEHAVIOR_DESTROY: END_BEHAVIOR_DESTROY,
     END_BEHAVIOR_PAUSE: END_BEHAVIOR_PAUSE,
@@ -4470,7 +4473,7 @@ var index$1 = /*#__PURE__*/Object.freeze({
     MESSAGE_ITEM_PHRASE_END: MESSAGE_ITEM_PHRASE_END,
     get ValueType () { return ValueType; },
     get BezierKeyframeType () { return BezierKeyframeType; },
-    get ItemEndBehavior () { return ItemEndBehavior; },
+    get EndBehavior () { return EndBehavior; },
     get ParentItemEndBehavior () { return ParentItemEndBehavior; },
     get ParticleInteractionBehavior () { return ParticleInteractionBehavior; },
     get ShapeArcMode () { return ShapeArcMode; },
@@ -16620,7 +16623,7 @@ exports.ParticleSystem = /*#__PURE__*/ function(Component) {
                             }
                         }
                     }
-                } else if (this.item.endBehavior === ItemEndBehavior.loop) {
+                } else if (this.item.endBehavior === EndBehavior.restart) {
                     updateTrail();
                     this.loopStartTime = now - duration;
                     this.lastEmitTime -= duration;
@@ -16639,12 +16642,12 @@ exports.ParticleSystem = /*#__PURE__*/ function(Component) {
                     this.ended = true;
                     this.onEnd(this);
                     var endBehavior = this.item.endBehavior;
-                    if (endBehavior === ItemEndBehavior.freeze) {
+                    if (endBehavior === EndBehavior.freeze) {
                         this.frozen = true;
                     }
                 }
-            } else if (this.item.endBehavior !== ItemEndBehavior.loop) {
-                if (ItemEndBehavior.destroy === this.item.endBehavior) {
+            } else if (this.item.endBehavior !== EndBehavior.restart) {
+                if (EndBehavior.destroy === this.item.endBehavior) {
                     var node = link.last;
                     if (node && node.content[0] < this.lastUpdate) {
                         this.destroyed = true;
@@ -18724,9 +18727,9 @@ var AnimationClipPlayable = /*#__PURE__*/ function(Playable) {
         var localTime = time - this.start;
         var duration = this.duration;
         if (localTime - duration > 0.001) {
-            if (this.endBehavior === ItemEndBehavior.loop) {
+            if (this.endBehavior === EndBehavior.restart) {
                 localTime = localTime % duration;
-            } else if (this.endBehavior === ItemEndBehavior.freeze) {
+            } else if (this.endBehavior === EndBehavior.freeze) {
                 localTime = Math.min(duration, localTime);
             }
         }
@@ -18852,7 +18855,7 @@ var RuntimeClip = /*#__PURE__*/ function() {
         var ended = false;
         var started = false;
         var boundObject = this.track.binding;
-        if (localTime > clip.start + clip.duration + 0.001 && clip.endBehavior === ItemEndBehavior.destroy) {
+        if (localTime > clip.start + clip.duration + 0.001 && clip.endBehavior === EndBehavior.destroy) {
             if (_instanceof1(boundObject, exports.VFXItem) && exports.VFXItem.isParticle(boundObject) && this.particleSystem && !this.particleSystem.destroyed) {
                 weight = 1.0;
             } else {
@@ -19160,7 +19163,7 @@ function compareTracks(a, b) {
         this.resolveBindings();
         this.timelinePlayable = this.timelineAsset.createPlayable(this.graph);
         // 重播不销毁元素
-        if (this.item.endBehavior !== ItemEndBehavior.destroy) {
+        if (this.item.endBehavior !== EndBehavior.destroy) {
             this.setReusable(true);
         }
     };
@@ -19227,7 +19230,7 @@ function compareTracks(a, b) {
                     compositionComponent.refId = refId;
                     item.transform.parentTransform = this.transform;
                     this.item.composition.refContent.push(item);
-                    if (item.endBehavior === ItemEndBehavior.loop) {
+                    if (item.endBehavior === EndBehavior.restart) {
                         this.item.composition.autoRefTex = false;
                     }
                     compositionComponent.createContent();
@@ -22209,8 +22212,8 @@ function getStandardCameraContent(model) {
     json.compositions.forEach(function(composition) {
         composition.items.forEach(function(item) {
             if (item.type === ItemType.null) {
-                if (item.endBehavior === ItemEndBehavior.destroy) {
-                    item.endBehavior = ItemEndBehavior.freeze;
+                if (item.endBehavior === EndBehavior.destroy) {
+                    item.endBehavior = EndBehavior.freeze;
                 }
             }
         });
@@ -22229,7 +22232,7 @@ function getStandardCameraContent(model) {
     json.compositions.forEach(function(composition) {
         composition.items.forEach(function(item) {
             if (item.type === ItemType.mesh || item.type === ItemType.light) {
-                item.endBehavior = item.endBehavior === 1 ? ItemEndBehavior.destroy : item.endBehavior;
+                item.endBehavior = item.endBehavior === 1 ? EndBehavior.destroy : item.endBehavior;
             }
         });
     });
@@ -22241,7 +22244,11 @@ function getStandardCameraContent(model) {
     var _loop = function() {
         var composition = _step1.value;
         // composition 的 endBehavior 兼容
-        if (composition.endBehavior === CompositionEndBehavior.pause_destroy || composition.endBehavior === CompositionEndBehavior.pause) {
+        if (// @ts-expect-error
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+        composition.endBehavior === END_BEHAVIOR_PAUSE_AND_DESTROY || // @ts-expect-error
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+        composition.endBehavior === END_BEHAVIOR_PAUSE) {
             composition.endBehavior = END_BEHAVIOR_FREEZE;
         }
         // 过滤掉滤镜元素
@@ -23028,13 +23035,13 @@ function getStandardItem(item, opt) {
         var looping = (_originContent_options = originContent.options) == null ? void 0 : _originContent_options.looping;
         if (looping) {
             if (Array.isArray(looping)) {
-                endBehavior = looping[1] ? ItemEndBehavior.loop : ItemEndBehavior.destroy;
+                endBehavior = looping[1] ? EndBehavior.restart : EndBehavior.destroy;
             } else {
-                endBehavior = ItemEndBehavior.loop;
+                endBehavior = EndBehavior.restart;
             }
         } else {
             var _originContent_options1;
-            endBehavior = endBehavior || (originContent == null ? void 0 : (_originContent_options1 = originContent.options) == null ? void 0 : _originContent_options1.endBehavior) || ItemEndBehavior.destroy;
+            endBehavior = endBehavior || (originContent == null ? void 0 : (_originContent_options1 = originContent.options) == null ? void 0 : _originContent_options1.endBehavior) || EndBehavior.destroy;
         }
         if (originContent.options.renderLevel) {
             renderLevel = originContent.options.renderLevel;
@@ -24379,7 +24386,7 @@ var listOrder = 0;
             id: id,
             duration: duration,
             name: name,
-            endBehavior: isNaN(endBehavior) ? END_BEHAVIOR_PAUSE : endBehavior,
+            endBehavior: isNaN(endBehavior) ? EndBehavior.freeze : endBehavior,
             // looping,
             items: items,
             camera: camera,
@@ -24563,7 +24570,7 @@ var listOrder = 0;
         };
         this.reusable = reusable;
         this.speed = speed;
-        this.autoRefTex = !this.keepResource && imageUsage && this.rootItem.endBehavior !== ItemEndBehavior.loop;
+        this.autoRefTex = !this.keepResource && imageUsage && this.rootItem.endBehavior !== EndBehavior.restart;
         this.name = sourceContent.name;
         this.pluginSystem = pluginSystem;
         this.pluginSystem.initializeComposition(this, scene);
@@ -24763,7 +24770,7 @@ var listOrder = 0;
    * @returns 重新播放合成标志位
    */ _proto.shouldRestart = function shouldRestart() {
         var _this_rootItem = this.rootItem, ended = _this_rootItem.ended, endBehavior = _this_rootItem.endBehavior;
-        return ended && endBehavior === ItemEndBehavior.loop;
+        return ended && endBehavior === EndBehavior.restart;
     };
     /**
    * 是否合成需要销毁
@@ -24816,9 +24823,9 @@ var listOrder = 0;
         var localTime = time - this.rootItem.start;
         var duration = this.rootItem.duration;
         if (localTime - duration > 0.001) {
-            if (this.rootItem.endBehavior === ItemEndBehavior.loop) {
+            if (this.rootItem.endBehavior === EndBehavior.restart) {
                 localTime = localTime % duration;
-            } else if (this.rootItem.endBehavior === ItemEndBehavior.freeze) {
+            } else if (this.rootItem.endBehavior === EndBehavior.freeze) {
                 localTime = Math.min(duration, localTime);
             }
         }
@@ -24869,7 +24876,7 @@ var listOrder = 0;
         for(var _iterator2 = _create_for_of_iterator_helper_loose(item.children), _step2; !(_step2 = _iterator2()).done;){
             var child = _step2.value;
             if (exports.VFXItem.isComposition(child)) {
-                if (child.ended && child.endBehavior === ItemEndBehavior.loop) {
+                if (child.ended && child.endBehavior === EndBehavior.restart) {
                     child.ended = false;
                     // TODO K帧动画在元素重建后需要 tick ，否则会导致元素位置和 k 帧第一帧位置不一致
                     this.callUpdate(child, 0);
@@ -25080,7 +25087,7 @@ var listOrder = 0;
         var _this = this;
         // 预合成元素销毁时销毁其中的item
         if (item.type == ItemType.composition) {
-            if (item.endBehavior !== ItemEndBehavior.freeze) {
+            if (item.endBehavior !== EndBehavior.freeze) {
                 var contentItems = item.getComponent(CompositionComponent).items;
                 contentItems.forEach(function(it) {
                     return _this.pluginSystem.plugins.forEach(function(loader) {
@@ -25339,6 +25346,1567 @@ var listOrder = 0;
     return Composition;
 }();
 
+var SIZEOF_SHORT = 2;
+var SIZEOF_INT = 4;
+var FILE_IDENTIFIER_LENGTH = 4;
+var SIZE_PREFIX_LENGTH = 4;
+
+var int32 = new Int32Array(2);
+var float32 = new Float32Array(int32.buffer);
+var float64 = new Float64Array(int32.buffer);
+var isLittleEndian = new Uint16Array(new Uint8Array([
+    1,
+    0
+]).buffer)[0] === 1;
+
+var Encoding;
+(function(Encoding) {
+    Encoding[Encoding["UTF8_BYTES"] = 1] = "UTF8_BYTES";
+    Encoding[Encoding["UTF16_STRING"] = 2] = "UTF16_STRING";
+})(Encoding || (Encoding = {}));
+
+var ByteBuffer = /*#__PURE__*/ function() {
+    function ByteBuffer(bytes_) {
+        this.bytes_ = bytes_;
+        this.position_ = 0;
+        this.text_decoder_ = new TextDecoder();
+    }
+    var _proto = ByteBuffer.prototype;
+    _proto.clear = function clear() {
+        this.position_ = 0;
+    };
+    /**
+     * Get the underlying `Uint8Array`.
+     */ _proto.bytes = function bytes() {
+        return this.bytes_;
+    };
+    /**
+     * Get the buffer's position.
+     */ _proto.position = function position() {
+        return this.position_;
+    };
+    /**
+     * Set the buffer's position.
+     */ _proto.setPosition = function setPosition(position) {
+        this.position_ = position;
+    };
+    /**
+     * Get the buffer's capacity.
+     */ _proto.capacity = function capacity() {
+        return this.bytes_.length;
+    };
+    _proto.readInt8 = function readInt8(offset) {
+        return this.readUint8(offset) << 24 >> 24;
+    };
+    _proto.readUint8 = function readUint8(offset) {
+        return this.bytes_[offset];
+    };
+    _proto.readInt16 = function readInt16(offset) {
+        return this.readUint16(offset) << 16 >> 16;
+    };
+    _proto.readUint16 = function readUint16(offset) {
+        return this.bytes_[offset] | this.bytes_[offset + 1] << 8;
+    };
+    _proto.readInt32 = function readInt32(offset) {
+        return this.bytes_[offset] | this.bytes_[offset + 1] << 8 | this.bytes_[offset + 2] << 16 | this.bytes_[offset + 3] << 24;
+    };
+    _proto.readUint32 = function readUint32(offset) {
+        return this.readInt32(offset) >>> 0;
+    };
+    _proto.readInt64 = function readInt64(offset) {
+        return BigInt.asIntN(64, BigInt(this.readUint32(offset)) + (BigInt(this.readUint32(offset + 4)) << BigInt(32)));
+    };
+    _proto.readUint64 = function readUint64(offset) {
+        return BigInt.asUintN(64, BigInt(this.readUint32(offset)) + (BigInt(this.readUint32(offset + 4)) << BigInt(32)));
+    };
+    _proto.readFloat32 = function readFloat32(offset) {
+        int32[0] = this.readInt32(offset);
+        return float32[0];
+    };
+    _proto.readFloat64 = function readFloat64(offset) {
+        int32[isLittleEndian ? 0 : 1] = this.readInt32(offset);
+        int32[isLittleEndian ? 1 : 0] = this.readInt32(offset + 4);
+        return float64[0];
+    };
+    _proto.writeInt8 = function writeInt8(offset, value) {
+        this.bytes_[offset] = value;
+    };
+    _proto.writeUint8 = function writeUint8(offset, value) {
+        this.bytes_[offset] = value;
+    };
+    _proto.writeInt16 = function writeInt16(offset, value) {
+        this.bytes_[offset] = value;
+        this.bytes_[offset + 1] = value >> 8;
+    };
+    _proto.writeUint16 = function writeUint16(offset, value) {
+        this.bytes_[offset] = value;
+        this.bytes_[offset + 1] = value >> 8;
+    };
+    _proto.writeInt32 = function writeInt32(offset, value) {
+        this.bytes_[offset] = value;
+        this.bytes_[offset + 1] = value >> 8;
+        this.bytes_[offset + 2] = value >> 16;
+        this.bytes_[offset + 3] = value >> 24;
+    };
+    _proto.writeUint32 = function writeUint32(offset, value) {
+        this.bytes_[offset] = value;
+        this.bytes_[offset + 1] = value >> 8;
+        this.bytes_[offset + 2] = value >> 16;
+        this.bytes_[offset + 3] = value >> 24;
+    };
+    _proto.writeInt64 = function writeInt64(offset, value) {
+        this.writeInt32(offset, Number(BigInt.asIntN(32, value)));
+        this.writeInt32(offset + 4, Number(BigInt.asIntN(32, value >> BigInt(32))));
+    };
+    _proto.writeUint64 = function writeUint64(offset, value) {
+        this.writeUint32(offset, Number(BigInt.asUintN(32, value)));
+        this.writeUint32(offset + 4, Number(BigInt.asUintN(32, value >> BigInt(32))));
+    };
+    _proto.writeFloat32 = function writeFloat32(offset, value) {
+        float32[0] = value;
+        this.writeInt32(offset, int32[0]);
+    };
+    _proto.writeFloat64 = function writeFloat64(offset, value) {
+        float64[0] = value;
+        this.writeInt32(offset, int32[isLittleEndian ? 0 : 1]);
+        this.writeInt32(offset + 4, int32[isLittleEndian ? 1 : 0]);
+    };
+    /**
+     * Return the file identifier.   Behavior is undefined for FlatBuffers whose
+     * schema does not include a file_identifier (likely points at padding or the
+     * start of a the root vtable).
+     */ _proto.getBufferIdentifier = function getBufferIdentifier() {
+        if (this.bytes_.length < this.position_ + SIZEOF_INT + FILE_IDENTIFIER_LENGTH) {
+            throw new Error("FlatBuffers: ByteBuffer is too short to contain an identifier.");
+        }
+        var result = "";
+        for(var i = 0; i < FILE_IDENTIFIER_LENGTH; i++){
+            result += String.fromCharCode(this.readInt8(this.position_ + SIZEOF_INT + i));
+        }
+        return result;
+    };
+    /**
+     * Look up a field in the vtable, return an offset into the object, or 0 if the
+     * field is not present.
+     */ _proto.__offset = function __offset(bb_pos, vtable_offset) {
+        var vtable = bb_pos - this.readInt32(bb_pos);
+        return vtable_offset < this.readInt16(vtable) ? this.readInt16(vtable + vtable_offset) : 0;
+    };
+    /**
+     * Initialize any Table-derived type to point to the union at the given offset.
+     */ _proto.__union = function __union(t, offset) {
+        t.bb_pos = offset + this.readInt32(offset);
+        t.bb = this;
+        return t;
+    };
+    /**
+     * Create a JavaScript string from UTF-8 data stored inside the FlatBuffer.
+     * This allocates a new string and converts to wide chars upon each access.
+     *
+     * To avoid the conversion to string, pass Encoding.UTF8_BYTES as the
+     * "optionalEncoding" argument. This is useful for avoiding conversion when
+     * the data will just be packaged back up in another FlatBuffer later on.
+     *
+     * @param offset
+     * @param opt_encoding Defaults to UTF16_STRING
+     */ _proto.__string = function __string(offset, opt_encoding) {
+        offset += this.readInt32(offset);
+        var length = this.readInt32(offset);
+        offset += SIZEOF_INT;
+        var utf8bytes = this.bytes_.subarray(offset, offset + length);
+        if (opt_encoding === Encoding.UTF8_BYTES) return utf8bytes;
+        else return this.text_decoder_.decode(utf8bytes);
+    };
+    /**
+     * Handle unions that can contain string as its member, if a Table-derived type then initialize it,
+     * if a string then return a new one
+     *
+     * WARNING: strings are immutable in JS so we can't change the string that the user gave us, this
+     * makes the behaviour of __union_with_string different compared to __union
+     */ _proto.__union_with_string = function __union_with_string(o, offset) {
+        if (typeof o === "string") {
+            return this.__string(offset);
+        }
+        return this.__union(o, offset);
+    };
+    /**
+     * Retrieve the relative offset stored at "offset"
+     */ _proto.__indirect = function __indirect(offset) {
+        return offset + this.readInt32(offset);
+    };
+    /**
+     * Get the start of data of a vector whose offset is stored at "offset" in this object.
+     */ _proto.__vector = function __vector(offset) {
+        return offset + this.readInt32(offset) + SIZEOF_INT; // data starts after the length
+    };
+    /**
+     * Get the length of a vector whose offset is stored at "offset" in this object.
+     */ _proto.__vector_len = function __vector_len(offset) {
+        return this.readInt32(offset + this.readInt32(offset));
+    };
+    _proto.__has_identifier = function __has_identifier(ident) {
+        if (ident.length != FILE_IDENTIFIER_LENGTH) {
+            throw new Error("FlatBuffers: file identifier must be length " + FILE_IDENTIFIER_LENGTH);
+        }
+        for(var i = 0; i < FILE_IDENTIFIER_LENGTH; i++){
+            if (ident.charCodeAt(i) != this.readInt8(this.position() + SIZEOF_INT + i)) {
+                return false;
+            }
+        }
+        return true;
+    };
+    /**
+     * A helper function for generating list for obj api
+     */ _proto.createScalarList = function createScalarList(listAccessor, listLength) {
+        var ret = [];
+        for(var i = 0; i < listLength; ++i){
+            var val = listAccessor(i);
+            if (val !== null) {
+                ret.push(val);
+            }
+        }
+        return ret;
+    };
+    /**
+     * A helper function for generating list for obj api
+     * @param listAccessor function that accepts an index and return data at that index
+     * @param listLength listLength
+     * @param res result list
+     */ _proto.createObjList = function createObjList(listAccessor, listLength) {
+        var ret = [];
+        for(var i = 0; i < listLength; ++i){
+            var val = listAccessor(i);
+            if (val !== null) {
+                ret.push(val.unpack());
+            }
+        }
+        return ret;
+    };
+    /**
+     * Create and allocate a new ByteBuffer with a given size.
+     */ ByteBuffer.allocate = function allocate(byte_size) {
+        return new ByteBuffer(new Uint8Array(byte_size));
+    };
+    return ByteBuffer;
+}();
+
+var Builder = /*#__PURE__*/ function() {
+    function Builder(opt_initial_size) {
+        /** Minimum alignment encountered so far. */ this.minalign = 1;
+        /** The vtable for the current table. */ this.vtable = null;
+        /** The amount of fields we're actually using. */ this.vtable_in_use = 0;
+        /** Whether we are currently serializing a table. */ this.isNested = false;
+        /** Starting offset of the current struct/table. */ this.object_start = 0;
+        /** List of offsets of all vtables. */ this.vtables = [];
+        /** For the current vector being built. */ this.vector_num_elems = 0;
+        /** False omits default values from the serialized data */ this.force_defaults = false;
+        this.string_maps = null;
+        this.text_encoder = new TextEncoder();
+        var initial_size;
+        if (!opt_initial_size) {
+            initial_size = 1024;
+        } else {
+            initial_size = opt_initial_size;
+        }
+        /**
+         * @type {ByteBuffer}
+         * @private
+         */ this.bb = ByteBuffer.allocate(initial_size);
+        this.space = initial_size;
+    }
+    var _proto = Builder.prototype;
+    _proto.clear = function clear() {
+        this.bb.clear();
+        this.space = this.bb.capacity();
+        this.minalign = 1;
+        this.vtable = null;
+        this.vtable_in_use = 0;
+        this.isNested = false;
+        this.object_start = 0;
+        this.vtables = [];
+        this.vector_num_elems = 0;
+        this.force_defaults = false;
+        this.string_maps = null;
+    };
+    /**
+     * In order to save space, fields that are set to their default value
+     * don't get serialized into the buffer. Forcing defaults provides a
+     * way to manually disable this optimization.
+     *
+     * @param forceDefaults true always serializes default values
+     */ _proto.forceDefaults = function forceDefaults(forceDefaults) {
+        this.force_defaults = forceDefaults;
+    };
+    /**
+     * Get the ByteBuffer representing the FlatBuffer. Only call this after you've
+     * called finish(). The actual data starts at the ByteBuffer's current position,
+     * not necessarily at 0.
+     */ _proto.dataBuffer = function dataBuffer() {
+        return this.bb;
+    };
+    /**
+     * Get the bytes representing the FlatBuffer. Only call this after you've
+     * called finish().
+     */ _proto.asUint8Array = function asUint8Array() {
+        return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset());
+    };
+    /**
+     * Prepare to write an element of `size` after `additional_bytes` have been
+     * written, e.g. if you write a string, you need to align such the int length
+     * field is aligned to 4 bytes, and the string data follows it directly. If all
+     * you need to do is alignment, `additional_bytes` will be 0.
+     *
+     * @param size This is the of the new element to write
+     * @param additional_bytes The padding size
+     */ _proto.prep = function prep(size, additional_bytes) {
+        // Track the biggest thing we've ever aligned to.
+        if (size > this.minalign) {
+            this.minalign = size;
+        }
+        // Find the amount of alignment needed such that `size` is properly
+        // aligned after `additional_bytes`
+        var align_size = ~(this.bb.capacity() - this.space + additional_bytes) + 1 & size - 1;
+        // Reallocate the buffer if needed.
+        while(this.space < align_size + size + additional_bytes){
+            var old_buf_size = this.bb.capacity();
+            this.bb = Builder.growByteBuffer(this.bb);
+            this.space += this.bb.capacity() - old_buf_size;
+        }
+        this.pad(align_size);
+    };
+    _proto.pad = function pad(byte_size) {
+        for(var i = 0; i < byte_size; i++){
+            this.bb.writeInt8(--this.space, 0);
+        }
+    };
+    _proto.writeInt8 = function writeInt8(value) {
+        this.bb.writeInt8(this.space -= 1, value);
+    };
+    _proto.writeInt16 = function writeInt16(value) {
+        this.bb.writeInt16(this.space -= 2, value);
+    };
+    _proto.writeInt32 = function writeInt32(value) {
+        this.bb.writeInt32(this.space -= 4, value);
+    };
+    _proto.writeInt64 = function writeInt64(value) {
+        this.bb.writeInt64(this.space -= 8, value);
+    };
+    _proto.writeFloat32 = function writeFloat32(value) {
+        this.bb.writeFloat32(this.space -= 4, value);
+    };
+    _proto.writeFloat64 = function writeFloat64(value) {
+        this.bb.writeFloat64(this.space -= 8, value);
+    };
+    /**
+     * Add an `int8` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `int8` to add the buffer.
+     */ _proto.addInt8 = function addInt8(value) {
+        this.prep(1, 0);
+        this.writeInt8(value);
+    };
+    /**
+     * Add an `int16` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `int16` to add the buffer.
+     */ _proto.addInt16 = function addInt16(value) {
+        this.prep(2, 0);
+        this.writeInt16(value);
+    };
+    /**
+     * Add an `int32` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `int32` to add the buffer.
+     */ _proto.addInt32 = function addInt32(value) {
+        this.prep(4, 0);
+        this.writeInt32(value);
+    };
+    /**
+     * Add an `int64` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `int64` to add the buffer.
+     */ _proto.addInt64 = function addInt64(value) {
+        this.prep(8, 0);
+        this.writeInt64(value);
+    };
+    /**
+     * Add a `float32` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `float32` to add the buffer.
+     */ _proto.addFloat32 = function addFloat32(value) {
+        this.prep(4, 0);
+        this.writeFloat32(value);
+    };
+    /**
+     * Add a `float64` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `float64` to add the buffer.
+     */ _proto.addFloat64 = function addFloat64(value) {
+        this.prep(8, 0);
+        this.writeFloat64(value);
+    };
+    _proto.addFieldInt8 = function addFieldInt8(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+            this.addInt8(value);
+            this.slot(voffset);
+        }
+    };
+    _proto.addFieldInt16 = function addFieldInt16(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+            this.addInt16(value);
+            this.slot(voffset);
+        }
+    };
+    _proto.addFieldInt32 = function addFieldInt32(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+            this.addInt32(value);
+            this.slot(voffset);
+        }
+    };
+    _proto.addFieldInt64 = function addFieldInt64(voffset, value, defaultValue) {
+        if (this.force_defaults || value !== defaultValue) {
+            this.addInt64(value);
+            this.slot(voffset);
+        }
+    };
+    _proto.addFieldFloat32 = function addFieldFloat32(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+            this.addFloat32(value);
+            this.slot(voffset);
+        }
+    };
+    _proto.addFieldFloat64 = function addFieldFloat64(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+            this.addFloat64(value);
+            this.slot(voffset);
+        }
+    };
+    _proto.addFieldOffset = function addFieldOffset(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+            this.addOffset(value);
+            this.slot(voffset);
+        }
+    };
+    /**
+     * Structs are stored inline, so nothing additional is being added. `d` is always 0.
+     */ _proto.addFieldStruct = function addFieldStruct(voffset, value, defaultValue) {
+        if (value != defaultValue) {
+            this.nested(value);
+            this.slot(voffset);
+        }
+    };
+    /**
+     * Structures are always stored inline, they need to be created right
+     * where they're used.  You'll get this assertion failure if you
+     * created it elsewhere.
+     */ _proto.nested = function nested(obj) {
+        if (obj != this.offset()) {
+            throw new TypeError("FlatBuffers: struct must be serialized inline.");
+        }
+    };
+    /**
+     * Should not be creating any other object, string or vector
+     * while an object is being constructed
+     */ _proto.notNested = function notNested() {
+        if (this.isNested) {
+            throw new TypeError("FlatBuffers: object serialization must not be nested.");
+        }
+    };
+    /**
+     * Set the current vtable at `voffset` to the current location in the buffer.
+     */ _proto.slot = function slot(voffset) {
+        if (this.vtable !== null) this.vtable[voffset] = this.offset();
+    };
+    /**
+     * @returns Offset relative to the end of the buffer.
+     */ _proto.offset = function offset() {
+        return this.bb.capacity() - this.space;
+    };
+    /**
+     * Adds on offset, relative to where it will be written.
+     *
+     * @param offset The offset to add.
+     */ _proto.addOffset = function addOffset(offset) {
+        this.prep(SIZEOF_INT, 0); // Ensure alignment is already done.
+        this.writeInt32(this.offset() - offset + SIZEOF_INT);
+    };
+    /**
+     * Start encoding a new object in the buffer.  Users will not usually need to
+     * call this directly. The FlatBuffers compiler will generate helper methods
+     * that call this method internally.
+     */ _proto.startObject = function startObject(numfields) {
+        this.notNested();
+        if (this.vtable == null) {
+            this.vtable = [];
+        }
+        this.vtable_in_use = numfields;
+        for(var i = 0; i < numfields; i++){
+            this.vtable[i] = 0; // This will push additional elements as needed
+        }
+        this.isNested = true;
+        this.object_start = this.offset();
+    };
+    /**
+     * Finish off writing the object that is under construction.
+     *
+     * @returns The offset to the object inside `dataBuffer`
+     */ _proto.endObject = function endObject() {
+        if (this.vtable == null || !this.isNested) {
+            throw new Error("FlatBuffers: endObject called without startObject");
+        }
+        this.addInt32(0);
+        var vtableloc = this.offset();
+        // Trim trailing zeroes.
+        var i = this.vtable_in_use - 1;
+        // eslint-disable-next-line no-empty
+        for(; i >= 0 && this.vtable[i] == 0; i--){}
+        var trimmed_size = i + 1;
+        // Write out the current vtable.
+        for(; i >= 0; i--){
+            // Offset relative to the start of the table.
+            this.addInt16(this.vtable[i] != 0 ? vtableloc - this.vtable[i] : 0);
+        }
+        var standard_fields = 2; // The fields below:
+        this.addInt16(vtableloc - this.object_start);
+        var len = (trimmed_size + standard_fields) * SIZEOF_SHORT;
+        this.addInt16(len);
+        // Search for an existing vtable that matches the current one.
+        var existing_vtable = 0;
+        var vt1 = this.space;
+        outer_loop: for(i = 0; i < this.vtables.length; i++){
+            var vt2 = this.bb.capacity() - this.vtables[i];
+            if (len == this.bb.readInt16(vt2)) {
+                for(var j = SIZEOF_SHORT; j < len; j += SIZEOF_SHORT){
+                    if (this.bb.readInt16(vt1 + j) != this.bb.readInt16(vt2 + j)) {
+                        continue outer_loop;
+                    }
+                }
+                existing_vtable = this.vtables[i];
+                break;
+            }
+        }
+        if (existing_vtable) {
+            // Found a match:
+            // Remove the current vtable.
+            this.space = this.bb.capacity() - vtableloc;
+            // Point table to existing vtable.
+            this.bb.writeInt32(this.space, existing_vtable - vtableloc);
+        } else {
+            // No match:
+            // Add the location of the current vtable to the list of vtables.
+            this.vtables.push(this.offset());
+            // Point table to current vtable.
+            this.bb.writeInt32(this.bb.capacity() - vtableloc, this.offset() - vtableloc);
+        }
+        this.isNested = false;
+        return vtableloc;
+    };
+    /**
+     * Finalize a buffer, poiting to the given `root_table`.
+     */ _proto.finish = function finish(root_table, opt_file_identifier, opt_size_prefix) {
+        var size_prefix = opt_size_prefix ? SIZE_PREFIX_LENGTH : 0;
+        if (opt_file_identifier) {
+            var file_identifier = opt_file_identifier;
+            this.prep(this.minalign, SIZEOF_INT + FILE_IDENTIFIER_LENGTH + size_prefix);
+            if (file_identifier.length != FILE_IDENTIFIER_LENGTH) {
+                throw new TypeError("FlatBuffers: file identifier must be length " + FILE_IDENTIFIER_LENGTH);
+            }
+            for(var i = FILE_IDENTIFIER_LENGTH - 1; i >= 0; i--){
+                this.writeInt8(file_identifier.charCodeAt(i));
+            }
+        }
+        this.prep(this.minalign, SIZEOF_INT + size_prefix);
+        this.addOffset(root_table);
+        if (size_prefix) {
+            this.addInt32(this.bb.capacity() - this.space);
+        }
+        this.bb.setPosition(this.space);
+    };
+    /**
+     * Finalize a size prefixed buffer, pointing to the given `root_table`.
+     */ _proto.finishSizePrefixed = function finishSizePrefixed(root_table, opt_file_identifier) {
+        this.finish(root_table, opt_file_identifier, true);
+    };
+    /**
+     * This checks a required field has been set in a given table that has
+     * just been constructed.
+     */ _proto.requiredField = function requiredField(table, field) {
+        var table_start = this.bb.capacity() - table;
+        var vtable_start = table_start - this.bb.readInt32(table_start);
+        var ok = field < this.bb.readInt16(vtable_start) && this.bb.readInt16(vtable_start + field) != 0;
+        // If this fails, the caller will show what field needs to be set.
+        if (!ok) {
+            throw new TypeError("FlatBuffers: field " + field + " must be set");
+        }
+    };
+    /**
+     * Start a new array/vector of objects.  Users usually will not call
+     * this directly. The FlatBuffers compiler will create a start/end
+     * method for vector types in generated code.
+     *
+     * @param elem_size The size of each element in the array
+     * @param num_elems The number of elements in the array
+     * @param alignment The alignment of the array
+     */ _proto.startVector = function startVector(elem_size, num_elems, alignment) {
+        this.notNested();
+        this.vector_num_elems = num_elems;
+        this.prep(SIZEOF_INT, elem_size * num_elems);
+        this.prep(alignment, elem_size * num_elems); // Just in case alignment > int.
+    };
+    /**
+     * Finish off the creation of an array and all its elements. The array must be
+     * created with `startVector`.
+     *
+     * @returns The offset at which the newly created array
+     * starts.
+     */ _proto.endVector = function endVector() {
+        this.writeInt32(this.vector_num_elems);
+        return this.offset();
+    };
+    /**
+     * Encode the string `s` in the buffer using UTF-8. If the string passed has
+     * already been seen, we return the offset of the already written string
+     *
+     * @param s The string to encode
+     * @return The offset in the buffer where the encoded string starts
+     */ _proto.createSharedString = function createSharedString(s) {
+        if (!s) {
+            return 0;
+        }
+        if (!this.string_maps) {
+            this.string_maps = new Map();
+        }
+        if (this.string_maps.has(s)) {
+            return this.string_maps.get(s);
+        }
+        var offset = this.createString(s);
+        this.string_maps.set(s, offset);
+        return offset;
+    };
+    /**
+     * Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed
+     * instead of a string, it is assumed to contain valid UTF-8 encoded data.
+     *
+     * @param s The string to encode
+     * @return The offset in the buffer where the encoded string starts
+     */ _proto.createString = function createString(s) {
+        if (s === null || s === undefined) {
+            return 0;
+        }
+        var utf8;
+        if (_instanceof1(s, Uint8Array)) {
+            utf8 = s;
+        } else {
+            utf8 = this.text_encoder.encode(s);
+        }
+        this.addInt8(0);
+        this.startVector(1, utf8.length, 1);
+        this.bb.setPosition(this.space -= utf8.length);
+        this.bb.bytes().set(utf8, this.space);
+        return this.endVector();
+    };
+    /**
+     * Create a byte vector.
+     *
+     * @param v The bytes to add
+     * @returns The offset in the buffer where the byte vector starts
+     */ _proto.createByteVector = function createByteVector(v) {
+        if (v === null || v === undefined) {
+            return 0;
+        }
+        this.startVector(1, v.length, 1);
+        this.bb.setPosition(this.space -= v.length);
+        this.bb.bytes().set(v, this.space);
+        return this.endVector();
+    };
+    /**
+     * A helper function to pack an object
+     *
+     * @returns offset of obj
+     */ _proto.createObjectOffset = function createObjectOffset(obj) {
+        if (obj === null) {
+            return 0;
+        }
+        if (typeof obj === "string") {
+            return this.createString(obj);
+        } else {
+            return obj.pack(this);
+        }
+    };
+    /**
+     * A helper function to pack a list of object
+     *
+     * @returns list of offsets of each non null object
+     */ _proto.createObjectOffsetList = function createObjectOffsetList(list) {
+        var ret = [];
+        for(var i = 0; i < list.length; ++i){
+            var val = list[i];
+            if (val !== null) {
+                ret.push(this.createObjectOffset(val));
+            } else {
+                throw new TypeError("FlatBuffers: Argument for createObjectOffsetList cannot contain null.");
+            }
+        }
+        return ret;
+    };
+    _proto.createStructOffsetList = function createStructOffsetList(list, startFunc) {
+        startFunc(this, list.length);
+        this.createObjectOffsetList(list.slice().reverse());
+        return this.endVector();
+    };
+    /**
+     * Doubles the size of the backing ByteBuffer and copies the old data towards
+     * the end of the new buffer (since we build the buffer backwards).
+     *
+     * @param bb The current buffer with the existing data
+     * @returns A new byte buffer with the old data copied
+     * to it. The data is located at the end of the buffer.
+     *
+     * uint8Array.set() formally takes {Array<number>|ArrayBufferView}, so to pass
+     * it a uint8Array we need to suppress the type check:
+     * @suppress {checkTypes}
+     */ Builder.growByteBuffer = function growByteBuffer(bb) {
+        var old_buf_size = bb.capacity();
+        // Ensure we don't grow beyond what fits in an int.
+        if (old_buf_size & 0xC0000000) {
+            throw new Error("FlatBuffers: cannot grow buffer beyond 2 gigabytes.");
+        }
+        var new_buf_size = old_buf_size << 1;
+        var nbb = ByteBuffer.allocate(new_buf_size);
+        nbb.setPosition(new_buf_size - old_buf_size);
+        nbb.bytes().set(bb.bytes(), new_buf_size - old_buf_size);
+        return nbb;
+    };
+    return Builder;
+}();
+
+// automatically generated by the FlatBuffers compiler, do not modify
+var FBEffectsObjectData = /*#__PURE__*/ function() {
+    function FBEffectsObjectData() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    var _proto = FBEffectsObjectData.prototype;
+    _proto.__init = function __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    };
+    _proto.dataType = function dataType(optionalEncoding) {
+        var offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    };
+    _proto.data = function data(index) {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
+    };
+    _proto.dataLength = function dataLength() {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    };
+    _proto.dataArray = function dataArray() {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+    };
+    _proto.unpack = function unpack() {
+        return new FBEffectsObjectDataT(this.dataType(), this.bb.createScalarList(this.data.bind(this), this.dataLength()));
+    };
+    _proto.unpackTo = function unpackTo(_o) {
+        _o.dataType = this.dataType();
+        _o.data = this.bb.createScalarList(this.data.bind(this), this.dataLength());
+    };
+    FBEffectsObjectData.getRootAsFBEffectsObjectData = function getRootAsFBEffectsObjectData(bb, obj) {
+        return (obj || new FBEffectsObjectData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBEffectsObjectData.getSizePrefixedRootAsFBEffectsObjectData = function getSizePrefixedRootAsFBEffectsObjectData(bb, obj) {
+        bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+        return (obj || new FBEffectsObjectData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBEffectsObjectData.startFBEffectsObjectData = function startFBEffectsObjectData(builder) {
+        builder.startObject(2);
+    };
+    FBEffectsObjectData.addDataType = function addDataType(builder, dataTypeOffset) {
+        builder.addFieldOffset(0, dataTypeOffset, 0);
+    };
+    FBEffectsObjectData.addData = function addData(builder, dataOffset) {
+        builder.addFieldOffset(1, dataOffset, 0);
+    };
+    FBEffectsObjectData.createDataVector = function createDataVector(builder, data) {
+        builder.startVector(1, data.length, 1);
+        for(var i = data.length - 1; i >= 0; i--){
+            builder.addInt8(data[i]);
+        }
+        return builder.endVector();
+    };
+    FBEffectsObjectData.startDataVector = function startDataVector(builder, numElems) {
+        builder.startVector(1, numElems, 1);
+    };
+    FBEffectsObjectData.endFBEffectsObjectData = function endFBEffectsObjectData(builder) {
+        var offset = builder.endObject();
+        return offset;
+    };
+    FBEffectsObjectData.createFBEffectsObjectData = function createFBEffectsObjectData(builder, dataTypeOffset, dataOffset) {
+        FBEffectsObjectData.startFBEffectsObjectData(builder);
+        FBEffectsObjectData.addDataType(builder, dataTypeOffset);
+        FBEffectsObjectData.addData(builder, dataOffset);
+        return FBEffectsObjectData.endFBEffectsObjectData(builder);
+    };
+    return FBEffectsObjectData;
+}();
+var FBEffectsObjectDataT = /*#__PURE__*/ function() {
+    function FBEffectsObjectDataT(dataType, data) {
+        if (dataType === void 0) dataType = null;
+        if (data === void 0) data = [];
+        this.dataType = dataType;
+        this.data = data;
+    }
+    var _proto = FBEffectsObjectDataT.prototype;
+    _proto.pack = function pack(builder) {
+        var dataType = this.dataType !== null ? builder.createString(this.dataType) : 0;
+        var data = FBEffectsObjectData.createDataVector(builder, this.data);
+        return FBEffectsObjectData.createFBEffectsObjectData(builder, dataType, data);
+    };
+    return FBEffectsObjectDataT;
+}();
+
+// automatically generated by the FlatBuffers compiler, do not modify
+var FBEffectsPackageData = /*#__PURE__*/ function() {
+    function FBEffectsPackageData() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    var _proto = FBEffectsPackageData.prototype;
+    _proto.__init = function __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    };
+    _proto.exportObjects = function exportObjects(index, obj) {
+        var offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new FBEffectsObjectData()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    };
+    _proto.exportObjectsLength = function exportObjectsLength() {
+        var offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    };
+    _proto.unpack = function unpack() {
+        return new FBEffectsPackageDataT(this.bb.createObjList(this.exportObjects.bind(this), this.exportObjectsLength()));
+    };
+    _proto.unpackTo = function unpackTo(_o) {
+        _o.exportObjects = this.bb.createObjList(this.exportObjects.bind(this), this.exportObjectsLength());
+    };
+    FBEffectsPackageData.getRootAsFBEffectsPackageData = function getRootAsFBEffectsPackageData(bb, obj) {
+        return (obj || new FBEffectsPackageData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBEffectsPackageData.getSizePrefixedRootAsFBEffectsPackageData = function getSizePrefixedRootAsFBEffectsPackageData(bb, obj) {
+        bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+        return (obj || new FBEffectsPackageData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBEffectsPackageData.startFBEffectsPackageData = function startFBEffectsPackageData(builder) {
+        builder.startObject(1);
+    };
+    FBEffectsPackageData.addExportObjects = function addExportObjects(builder, exportObjectsOffset) {
+        builder.addFieldOffset(0, exportObjectsOffset, 0);
+    };
+    FBEffectsPackageData.createExportObjectsVector = function createExportObjectsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for(var i = data.length - 1; i >= 0; i--){
+            builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+    };
+    FBEffectsPackageData.startExportObjectsVector = function startExportObjectsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    };
+    FBEffectsPackageData.endFBEffectsPackageData = function endFBEffectsPackageData(builder) {
+        var offset = builder.endObject();
+        return offset;
+    };
+    FBEffectsPackageData.finishFBEffectsPackageDataBuffer = function finishFBEffectsPackageDataBuffer(builder, offset) {
+        builder.finish(offset);
+    };
+    FBEffectsPackageData.finishSizePrefixedFBEffectsPackageDataBuffer = function finishSizePrefixedFBEffectsPackageDataBuffer(builder, offset) {
+        builder.finish(offset, undefined, true);
+    };
+    FBEffectsPackageData.createFBEffectsPackageData = function createFBEffectsPackageData(builder, exportObjectsOffset) {
+        FBEffectsPackageData.startFBEffectsPackageData(builder);
+        FBEffectsPackageData.addExportObjects(builder, exportObjectsOffset);
+        return FBEffectsPackageData.endFBEffectsPackageData(builder);
+    };
+    return FBEffectsPackageData;
+}();
+var FBEffectsPackageDataT = /*#__PURE__*/ function() {
+    function FBEffectsPackageDataT(exportObjects) {
+        if (exportObjects === void 0) exportObjects = [];
+        this.exportObjects = exportObjects;
+    }
+    var _proto = FBEffectsPackageDataT.prototype;
+    _proto.pack = function pack(builder) {
+        var exportObjects = FBEffectsPackageData.createExportObjectsVector(builder, builder.createObjectOffsetList(this.exportObjects));
+        return FBEffectsPackageData.createFBEffectsPackageData(builder, exportObjects);
+    };
+    return FBEffectsPackageDataT;
+}();
+
+// automatically generated by the FlatBuffers compiler, do not modify
+var FBSubMesh = /*#__PURE__*/ function() {
+    function FBSubMesh() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    var _proto = FBSubMesh.prototype;
+    _proto.__init = function __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    };
+    _proto.offset = function offset() {
+        var offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.indexCount = function indexCount() {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.vertexCount = function vertexCount() {
+        var offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.unpack = function unpack() {
+        return new FBSubMeshT(this.offset(), this.indexCount(), this.vertexCount());
+    };
+    _proto.unpackTo = function unpackTo(_o) {
+        _o.offset = this.offset();
+        _o.indexCount = this.indexCount();
+        _o.vertexCount = this.vertexCount();
+    };
+    FBSubMesh.getRootAsFBSubMesh = function getRootAsFBSubMesh(bb, obj) {
+        return (obj || new FBSubMesh()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBSubMesh.getSizePrefixedRootAsFBSubMesh = function getSizePrefixedRootAsFBSubMesh(bb, obj) {
+        bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+        return (obj || new FBSubMesh()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBSubMesh.startFBSubMesh = function startFBSubMesh(builder) {
+        builder.startObject(3);
+    };
+    FBSubMesh.addOffset = function addOffset(builder, offset) {
+        builder.addFieldInt32(0, offset, 0);
+    };
+    FBSubMesh.addIndexCount = function addIndexCount(builder, indexCount) {
+        builder.addFieldInt32(1, indexCount, 0);
+    };
+    FBSubMesh.addVertexCount = function addVertexCount(builder, vertexCount) {
+        builder.addFieldInt32(2, vertexCount, 0);
+    };
+    FBSubMesh.endFBSubMesh = function endFBSubMesh(builder) {
+        var offset = builder.endObject();
+        return offset;
+    };
+    FBSubMesh.createFBSubMesh = function createFBSubMesh(builder, offset, indexCount, vertexCount) {
+        FBSubMesh.startFBSubMesh(builder);
+        FBSubMesh.addOffset(builder, offset);
+        FBSubMesh.addIndexCount(builder, indexCount);
+        FBSubMesh.addVertexCount(builder, vertexCount);
+        return FBSubMesh.endFBSubMesh(builder);
+    };
+    return FBSubMesh;
+}();
+var FBSubMeshT = /*#__PURE__*/ function() {
+    function FBSubMeshT(offset, indexCount, vertexCount) {
+        if (offset === void 0) offset = 0;
+        if (indexCount === void 0) indexCount = 0;
+        if (vertexCount === void 0) vertexCount = 0;
+        this.offset = offset;
+        this.indexCount = indexCount;
+        this.vertexCount = vertexCount;
+    }
+    var _proto = FBSubMeshT.prototype;
+    _proto.pack = function pack(builder) {
+        return FBSubMesh.createFBSubMesh(builder, this.offset, this.indexCount, this.vertexCount);
+    };
+    return FBSubMeshT;
+}();
+
+// automatically generated by the FlatBuffers compiler, do not modify
+var FBVertexChannel = /*#__PURE__*/ function() {
+    function FBVertexChannel() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    var _proto = FBVertexChannel.prototype;
+    _proto.__init = function __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    };
+    _proto.semantic = function semantic(optionalEncoding) {
+        var offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    };
+    _proto.offset = function offset() {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.format = function format() {
+        var offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.dimension = function dimension() {
+        var offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.normalize = function normalize() {
+        var offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+    };
+    _proto.unpack = function unpack() {
+        return new FBVertexChannelT(this.semantic(), this.offset(), this.format(), this.dimension(), this.normalize());
+    };
+    _proto.unpackTo = function unpackTo(_o) {
+        _o.semantic = this.semantic();
+        _o.offset = this.offset();
+        _o.format = this.format();
+        _o.dimension = this.dimension();
+        _o.normalize = this.normalize();
+    };
+    FBVertexChannel.getRootAsFBVertexChannel = function getRootAsFBVertexChannel(bb, obj) {
+        return (obj || new FBVertexChannel()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBVertexChannel.getSizePrefixedRootAsFBVertexChannel = function getSizePrefixedRootAsFBVertexChannel(bb, obj) {
+        bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+        return (obj || new FBVertexChannel()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBVertexChannel.startFBVertexChannel = function startFBVertexChannel(builder) {
+        builder.startObject(5);
+    };
+    FBVertexChannel.addSemantic = function addSemantic(builder, semanticOffset) {
+        builder.addFieldOffset(0, semanticOffset, 0);
+    };
+    FBVertexChannel.addOffset = function addOffset(builder, offset) {
+        builder.addFieldInt32(1, offset, 0);
+    };
+    FBVertexChannel.addFormat = function addFormat(builder, format) {
+        builder.addFieldInt32(2, format, 0);
+    };
+    FBVertexChannel.addDimension = function addDimension(builder, dimension) {
+        builder.addFieldInt32(3, dimension, 0);
+    };
+    FBVertexChannel.addNormalize = function addNormalize(builder, normalize) {
+        builder.addFieldInt8(4, +normalize, +false);
+    };
+    FBVertexChannel.endFBVertexChannel = function endFBVertexChannel(builder) {
+        var offset = builder.endObject();
+        return offset;
+    };
+    FBVertexChannel.createFBVertexChannel = function createFBVertexChannel(builder, semanticOffset, offset, format, dimension, normalize) {
+        FBVertexChannel.startFBVertexChannel(builder);
+        FBVertexChannel.addSemantic(builder, semanticOffset);
+        FBVertexChannel.addOffset(builder, offset);
+        FBVertexChannel.addFormat(builder, format);
+        FBVertexChannel.addDimension(builder, dimension);
+        FBVertexChannel.addNormalize(builder, normalize);
+        return FBVertexChannel.endFBVertexChannel(builder);
+    };
+    return FBVertexChannel;
+}();
+var FBVertexChannelT = /*#__PURE__*/ function() {
+    function FBVertexChannelT(semantic, offset, format, dimension, normalize) {
+        if (semantic === void 0) semantic = null;
+        if (offset === void 0) offset = 0;
+        if (format === void 0) format = 0;
+        if (dimension === void 0) dimension = 0;
+        if (normalize === void 0) normalize = false;
+        this.semantic = semantic;
+        this.offset = offset;
+        this.format = format;
+        this.dimension = dimension;
+        this.normalize = normalize;
+    }
+    var _proto = FBVertexChannelT.prototype;
+    _proto.pack = function pack(builder) {
+        var semantic = this.semantic !== null ? builder.createString(this.semantic) : 0;
+        return FBVertexChannel.createFBVertexChannel(builder, semantic, this.offset, this.format, this.dimension, this.normalize);
+    };
+    return FBVertexChannelT;
+}();
+
+// automatically generated by the FlatBuffers compiler, do not modify
+var FBVertexData = /*#__PURE__*/ function() {
+    function FBVertexData() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    var _proto = FBVertexData.prototype;
+    _proto.__init = function __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    };
+    _proto.vertexCount = function vertexCount() {
+        var offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.channels = function channels(index, obj) {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new FBVertexChannel()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    };
+    _proto.channelsLength = function channelsLength() {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    };
+    _proto.unpack = function unpack() {
+        return new FBVertexDataT(this.vertexCount(), this.bb.createObjList(this.channels.bind(this), this.channelsLength()));
+    };
+    _proto.unpackTo = function unpackTo(_o) {
+        _o.vertexCount = this.vertexCount();
+        _o.channels = this.bb.createObjList(this.channels.bind(this), this.channelsLength());
+    };
+    FBVertexData.getRootAsFBVertexData = function getRootAsFBVertexData(bb, obj) {
+        return (obj || new FBVertexData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBVertexData.getSizePrefixedRootAsFBVertexData = function getSizePrefixedRootAsFBVertexData(bb, obj) {
+        bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+        return (obj || new FBVertexData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBVertexData.startFBVertexData = function startFBVertexData(builder) {
+        builder.startObject(2);
+    };
+    FBVertexData.addVertexCount = function addVertexCount(builder, vertexCount) {
+        builder.addFieldInt32(0, vertexCount, 0);
+    };
+    FBVertexData.addChannels = function addChannels(builder, channelsOffset) {
+        builder.addFieldOffset(1, channelsOffset, 0);
+    };
+    FBVertexData.createChannelsVector = function createChannelsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for(var i = data.length - 1; i >= 0; i--){
+            builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+    };
+    FBVertexData.startChannelsVector = function startChannelsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    };
+    FBVertexData.endFBVertexData = function endFBVertexData(builder) {
+        var offset = builder.endObject();
+        return offset;
+    };
+    FBVertexData.createFBVertexData = function createFBVertexData(builder, vertexCount, channelsOffset) {
+        FBVertexData.startFBVertexData(builder);
+        FBVertexData.addVertexCount(builder, vertexCount);
+        FBVertexData.addChannels(builder, channelsOffset);
+        return FBVertexData.endFBVertexData(builder);
+    };
+    return FBVertexData;
+}();
+var FBVertexDataT = /*#__PURE__*/ function() {
+    function FBVertexDataT(vertexCount, channels) {
+        if (vertexCount === void 0) vertexCount = 0;
+        if (channels === void 0) channels = [];
+        this.vertexCount = vertexCount;
+        this.channels = channels;
+    }
+    var _proto = FBVertexDataT.prototype;
+    _proto.pack = function pack(builder) {
+        var channels = FBVertexData.createChannelsVector(builder, builder.createObjectOffsetList(this.channels));
+        return FBVertexData.createFBVertexData(builder, this.vertexCount, channels);
+    };
+    return FBVertexDataT;
+}();
+
+// automatically generated by the FlatBuffers compiler, do not modify
+var FBGeometryData = /*#__PURE__*/ function() {
+    function FBGeometryData() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    var _proto = FBGeometryData.prototype;
+    _proto.__init = function __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    };
+    _proto.id = function id(optionalEncoding) {
+        var offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    };
+    _proto.name = function name(optionalEncoding) {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    };
+    _proto.vertexData = function vertexData(obj) {
+        var offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? (obj || new FBVertexData()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    };
+    _proto.indexFormat = function indexFormat() {
+        var offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.indexOffset = function indexOffset() {
+        var offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.subMeshes = function subMeshes(index, obj) {
+        var offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? (obj || new FBSubMesh()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    };
+    _proto.subMeshesLength = function subMeshesLength() {
+        var offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    };
+    _proto.mode = function mode() {
+        var offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.buffer = function buffer(optionalEncoding) {
+        var offset = this.bb.__offset(this.bb_pos, 18);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    };
+    _proto.binaryData = function binaryData(index) {
+        var offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
+    };
+    _proto.binaryDataLength = function binaryDataLength() {
+        var offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    };
+    _proto.binaryDataArray = function binaryDataArray() {
+        var offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+    };
+    _proto.boneNames = function boneNames(index, optionalEncoding) {
+        var offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
+    };
+    _proto.boneNamesLength = function boneNamesLength() {
+        var offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    };
+    _proto.rootBoneName = function rootBoneName(optionalEncoding) {
+        var offset = this.bb.__offset(this.bb_pos, 24);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    };
+    _proto.inverseBindMatrices = function inverseBindMatrices(index) {
+        var offset = this.bb.__offset(this.bb_pos, 26);
+        return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
+    };
+    _proto.inverseBindMatricesLength = function inverseBindMatricesLength() {
+        var offset = this.bb.__offset(this.bb_pos, 26);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    };
+    _proto.inverseBindMatricesArray = function inverseBindMatricesArray() {
+        var offset = this.bb.__offset(this.bb_pos, 26);
+        return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+    };
+    _proto.unpack = function unpack() {
+        return new FBGeometryDataT(this.id(), this.name(), this.vertexData() !== null ? this.vertexData().unpack() : null, this.indexFormat(), this.indexOffset(), this.bb.createObjList(this.subMeshes.bind(this), this.subMeshesLength()), this.mode(), this.buffer(), this.bb.createScalarList(this.binaryData.bind(this), this.binaryDataLength()), this.bb.createScalarList(this.boneNames.bind(this), this.boneNamesLength()), this.rootBoneName(), this.bb.createScalarList(this.inverseBindMatrices.bind(this), this.inverseBindMatricesLength()));
+    };
+    _proto.unpackTo = function unpackTo(_o) {
+        _o.id = this.id();
+        _o.name = this.name();
+        _o.vertexData = this.vertexData() !== null ? this.vertexData().unpack() : null;
+        _o.indexFormat = this.indexFormat();
+        _o.indexOffset = this.indexOffset();
+        _o.subMeshes = this.bb.createObjList(this.subMeshes.bind(this), this.subMeshesLength());
+        _o.mode = this.mode();
+        _o.buffer = this.buffer();
+        _o.binaryData = this.bb.createScalarList(this.binaryData.bind(this), this.binaryDataLength());
+        _o.boneNames = this.bb.createScalarList(this.boneNames.bind(this), this.boneNamesLength());
+        _o.rootBoneName = this.rootBoneName();
+        _o.inverseBindMatrices = this.bb.createScalarList(this.inverseBindMatrices.bind(this), this.inverseBindMatricesLength());
+    };
+    FBGeometryData.getRootAsFBGeometryData = function getRootAsFBGeometryData(bb, obj) {
+        return (obj || new FBGeometryData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBGeometryData.getSizePrefixedRootAsFBGeometryData = function getSizePrefixedRootAsFBGeometryData(bb, obj) {
+        bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+        return (obj || new FBGeometryData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBGeometryData.startFBGeometryData = function startFBGeometryData(builder) {
+        builder.startObject(12);
+    };
+    FBGeometryData.addId = function addId(builder, idOffset) {
+        builder.addFieldOffset(0, idOffset, 0);
+    };
+    FBGeometryData.addName = function addName(builder, nameOffset) {
+        builder.addFieldOffset(1, nameOffset, 0);
+    };
+    FBGeometryData.addVertexData = function addVertexData(builder, vertexDataOffset) {
+        builder.addFieldOffset(2, vertexDataOffset, 0);
+    };
+    FBGeometryData.addIndexFormat = function addIndexFormat(builder, indexFormat) {
+        builder.addFieldInt32(3, indexFormat, 0);
+    };
+    FBGeometryData.addIndexOffset = function addIndexOffset(builder, indexOffset) {
+        builder.addFieldInt32(4, indexOffset, 0);
+    };
+    FBGeometryData.addSubMeshes = function addSubMeshes(builder, subMeshesOffset) {
+        builder.addFieldOffset(5, subMeshesOffset, 0);
+    };
+    FBGeometryData.createSubMeshesVector = function createSubMeshesVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for(var i = data.length - 1; i >= 0; i--){
+            builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+    };
+    FBGeometryData.startSubMeshesVector = function startSubMeshesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    };
+    FBGeometryData.addMode = function addMode(builder, mode) {
+        builder.addFieldInt32(6, mode, 0);
+    };
+    FBGeometryData.addBuffer = function addBuffer(builder, bufferOffset) {
+        builder.addFieldOffset(7, bufferOffset, 0);
+    };
+    FBGeometryData.addBinaryData = function addBinaryData(builder, binaryDataOffset) {
+        builder.addFieldOffset(8, binaryDataOffset, 0);
+    };
+    FBGeometryData.createBinaryDataVector = function createBinaryDataVector(builder, data) {
+        builder.startVector(1, data.length, 1);
+        for(var i = data.length - 1; i >= 0; i--){
+            builder.addInt8(data[i]);
+        }
+        return builder.endVector();
+    };
+    FBGeometryData.startBinaryDataVector = function startBinaryDataVector(builder, numElems) {
+        builder.startVector(1, numElems, 1);
+    };
+    FBGeometryData.addBoneNames = function addBoneNames(builder, boneNamesOffset) {
+        builder.addFieldOffset(9, boneNamesOffset, 0);
+    };
+    FBGeometryData.createBoneNamesVector = function createBoneNamesVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for(var i = data.length - 1; i >= 0; i--){
+            builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+    };
+    FBGeometryData.startBoneNamesVector = function startBoneNamesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    };
+    FBGeometryData.addRootBoneName = function addRootBoneName(builder, rootBoneNameOffset) {
+        builder.addFieldOffset(10, rootBoneNameOffset, 0);
+    };
+    FBGeometryData.addInverseBindMatrices = function addInverseBindMatrices(builder, inverseBindMatricesOffset) {
+        builder.addFieldOffset(11, inverseBindMatricesOffset, 0);
+    };
+    FBGeometryData.createInverseBindMatricesVector = function createInverseBindMatricesVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for(var i = data.length - 1; i >= 0; i--){
+            builder.addFloat32(data[i]);
+        }
+        return builder.endVector();
+    };
+    FBGeometryData.startInverseBindMatricesVector = function startInverseBindMatricesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    };
+    FBGeometryData.endFBGeometryData = function endFBGeometryData(builder) {
+        var offset = builder.endObject();
+        return offset;
+    };
+    return FBGeometryData;
+}();
+var FBGeometryDataT = /*#__PURE__*/ function() {
+    function FBGeometryDataT(id, name, vertexData, indexFormat, indexOffset, subMeshes, mode, buffer, binaryData, boneNames, rootBoneName, inverseBindMatrices) {
+        if (id === void 0) id = null;
+        if (name === void 0) name = null;
+        if (vertexData === void 0) vertexData = null;
+        if (indexFormat === void 0) indexFormat = 0;
+        if (indexOffset === void 0) indexOffset = 0;
+        if (subMeshes === void 0) subMeshes = [];
+        if (mode === void 0) mode = 0;
+        if (buffer === void 0) buffer = null;
+        if (binaryData === void 0) binaryData = [];
+        if (boneNames === void 0) boneNames = [];
+        if (rootBoneName === void 0) rootBoneName = null;
+        if (inverseBindMatrices === void 0) inverseBindMatrices = [];
+        this.id = id;
+        this.name = name;
+        this.vertexData = vertexData;
+        this.indexFormat = indexFormat;
+        this.indexOffset = indexOffset;
+        this.subMeshes = subMeshes;
+        this.mode = mode;
+        this.buffer = buffer;
+        this.binaryData = binaryData;
+        this.boneNames = boneNames;
+        this.rootBoneName = rootBoneName;
+        this.inverseBindMatrices = inverseBindMatrices;
+    }
+    var _proto = FBGeometryDataT.prototype;
+    _proto.pack = function pack(builder) {
+        var id = this.id !== null ? builder.createString(this.id) : 0;
+        var name = this.name !== null ? builder.createString(this.name) : 0;
+        var vertexData = this.vertexData !== null ? this.vertexData.pack(builder) : 0;
+        var subMeshes = FBGeometryData.createSubMeshesVector(builder, builder.createObjectOffsetList(this.subMeshes));
+        var buffer = this.buffer !== null ? builder.createString(this.buffer) : 0;
+        var binaryData = FBGeometryData.createBinaryDataVector(builder, this.binaryData);
+        var boneNames = FBGeometryData.createBoneNamesVector(builder, builder.createObjectOffsetList(this.boneNames));
+        var rootBoneName = this.rootBoneName !== null ? builder.createString(this.rootBoneName) : 0;
+        var inverseBindMatrices = FBGeometryData.createInverseBindMatricesVector(builder, this.inverseBindMatrices);
+        FBGeometryData.startFBGeometryData(builder);
+        FBGeometryData.addId(builder, id);
+        FBGeometryData.addName(builder, name);
+        FBGeometryData.addVertexData(builder, vertexData);
+        FBGeometryData.addIndexFormat(builder, this.indexFormat);
+        FBGeometryData.addIndexOffset(builder, this.indexOffset);
+        FBGeometryData.addSubMeshes(builder, subMeshes);
+        FBGeometryData.addMode(builder, this.mode);
+        FBGeometryData.addBuffer(builder, buffer);
+        FBGeometryData.addBinaryData(builder, binaryData);
+        FBGeometryData.addBoneNames(builder, boneNames);
+        FBGeometryData.addRootBoneName(builder, rootBoneName);
+        FBGeometryData.addInverseBindMatrices(builder, inverseBindMatrices);
+        return FBGeometryData.endFBGeometryData(builder);
+    };
+    return FBGeometryDataT;
+}();
+
+var EffectsPackage = /*#__PURE__*/ function() {
+    function EffectsPackage() {
+        this.exportObjectDatas = [];
+    }
+    var _proto = EffectsPackage.prototype;
+    _proto.addData = function addData(effectsObjectData) {
+        this.exportObjectDatas.push(effectsObjectData);
+    };
+    _proto.serializeToBinary = function serializeToBinary() {
+        var fbb = new Builder(1);
+        var effectsPackage = new FBEffectsPackageDataT();
+        var exportObjects = [];
+        for(var _iterator = _create_for_of_iterator_helper_loose(this.exportObjectDatas), _step; !(_step = _iterator()).done;){
+            var effectsObjectData = _step.value;
+            var fbEffectsObjectData = void 0;
+            if (effectsObjectData.dataType === DataType.Geometry) {
+                fbEffectsObjectData = new FBEffectsObjectDataT("Geometry", this.geometryDataToBinary(effectsObjectData));
+            }
+            if (!fbEffectsObjectData) {
+                continue;
+            }
+            exportObjects.push(fbEffectsObjectData);
+        }
+        effectsPackage.exportObjects = exportObjects;
+        FBEffectsPackageData.finishFBEffectsPackageDataBuffer(fbb, effectsPackage.pack(fbb));
+        var buffer = fbb.asUint8Array(); // Of type `Uint8Array`.
+        return buffer;
+    };
+    _proto.deserializeFromBinary = function deserializeFromBinary(buffer) {
+        var buf = new ByteBuffer(buffer);
+        var fbEffectsPackage = FBEffectsPackageData.getRootAsFBEffectsPackageData(buf);
+        for(var i = 0; i < fbEffectsPackage.exportObjectsLength(); i++){
+            var fbEffectsObjectData = fbEffectsPackage.exportObjects(i);
+            if (!fbEffectsObjectData) {
+                continue;
+            }
+            var dataBuffer = fbEffectsObjectData.dataArray();
+            var dataType = fbEffectsObjectData.dataType();
+            if (!dataBuffer) {
+                continue;
+            }
+            var effectsObjectData = void 0;
+            if (dataType === DataType.Geometry) {
+                effectsObjectData = this.binaryToGeometryData(dataBuffer);
+            }
+            if (!effectsObjectData) {
+                continue;
+            }
+            this.exportObjectDatas.push(effectsObjectData);
+        }
+    };
+    _proto.geometryDataToBinary = function geometryDataToBinary(geometryData) {
+        var fbb = new Builder(1);
+        var fbGeometryData = new FBGeometryDataT();
+        fbGeometryData.indexFormat = geometryData.indexFormat;
+        fbGeometryData.indexOffset = geometryData.indexOffset;
+        fbGeometryData.mode = geometryData.mode;
+        fbGeometryData.id = geometryData.id;
+        var _geometryData_boneNames;
+        fbGeometryData.boneNames = (_geometryData_boneNames = geometryData.boneNames) != null ? _geometryData_boneNames : [];
+        var _geometryData_rootBoneName;
+        fbGeometryData.rootBoneName = (_geometryData_rootBoneName = geometryData.rootBoneName) != null ? _geometryData_rootBoneName : "";
+        var _geometryData_inverseBindMatrices;
+        fbGeometryData.inverseBindMatrices = (_geometryData_inverseBindMatrices = geometryData.inverseBindMatrices) != null ? _geometryData_inverseBindMatrices : [];
+        var _geometryData_binaryData;
+        fbGeometryData.binaryData = (_geometryData_binaryData = geometryData.binaryData) != null ? _geometryData_binaryData : [];
+        var fbVertexdata = new FBVertexDataT();
+        fbVertexdata.vertexCount = geometryData.vertexData.vertexCount;
+        fbVertexdata.channels = [];
+        for(var _iterator = _create_for_of_iterator_helper_loose(geometryData.vertexData.channels), _step; !(_step = _iterator()).done;){
+            var channel = _step.value;
+            var fbChannel = new FBVertexChannelT(channel.semantic, channel.offset, channel.format, channel.dimension, channel.normalize);
+            fbVertexdata.channels.push(fbChannel);
+        }
+        fbGeometryData.vertexData = fbVertexdata;
+        var fbSubMeshes = [];
+        for(var _iterator1 = _create_for_of_iterator_helper_loose(geometryData.subMeshes), _step1; !(_step1 = _iterator1()).done;){
+            var subMesh = _step1.value;
+            var fbSubMesh = new FBSubMeshT(subMesh.offset, subMesh.indexCount, subMesh.vertexCount);
+            fbSubMeshes.push(fbSubMesh);
+        }
+        fbGeometryData.subMeshes = fbSubMeshes;
+        FBEffectsPackageData.finishFBEffectsPackageDataBuffer(fbb, fbGeometryData.pack(fbb));
+        var buffer = fbb.asUint8Array(); // Of type `Uint8Array`.
+        return buffer;
+    };
+    _proto.binaryToGeometryData = function binaryToGeometryData(buffer) {
+        var buf = new ByteBuffer(buffer);
+        var fbGeometryData = FBGeometryData.getRootAsFBGeometryData(buf);
+        var vertexData = {
+            vertexCount: 0,
+            channels: []
+        };
+        var fbVertexData = fbGeometryData.vertexData();
+        if (fbVertexData) {
+            vertexData.vertexCount = fbVertexData.vertexCount();
+            for(var i = 0; i < fbVertexData.channelsLength(); i++){
+                var channel = fbVertexData.channels(i);
+                if (!channel) {
+                    continue;
+                }
+                var _channel_semantic;
+                var vertexChannel = {
+                    semantic: (_channel_semantic = channel.semantic()) != null ? _channel_semantic : "",
+                    offset: channel.offset(),
+                    format: channel.format(),
+                    dimension: channel.dimension()
+                };
+                vertexData.channels.push(vertexChannel);
+            }
+        }
+        var subMeshes = [];
+        for(var i1 = 0; i1 < fbGeometryData.subMeshesLength(); i1++){
+            var fbSubMesh = fbGeometryData.subMeshes(i1);
+            if (!fbSubMesh) {
+                continue;
+            }
+            var subMesh = {
+                offset: fbSubMesh.offset(),
+                vertexCount: fbSubMesh.vertexCount()
+            };
+            subMeshes.push(subMesh);
+        }
+        var boneNames = [];
+        for(var i2 = 0; i2 < fbGeometryData.boneNamesLength(); i2++){
+            var boneName = fbGeometryData.boneNames(i2);
+            boneNames.push(boneName);
+        }
+        var inverseBindMatricesArray = fbGeometryData.inverseBindMatricesArray();
+        var _fbGeometryData_buffer, _fbGeometryData_rootBoneName, _fbGeometryData_binaryDataArray, _fbGeometryData_id;
+        var geometryData = {
+            vertexData: vertexData,
+            indexFormat: fbGeometryData.indexFormat(),
+            indexOffset: fbGeometryData.indexOffset(),
+            subMeshes: subMeshes,
+            mode: fbGeometryData.mode(),
+            buffer: (_fbGeometryData_buffer = fbGeometryData.buffer()) != null ? _fbGeometryData_buffer : "",
+            boneNames: boneNames,
+            rootBoneName: (_fbGeometryData_rootBoneName = fbGeometryData.rootBoneName()) != null ? _fbGeometryData_rootBoneName : "",
+            inverseBindMatrices: inverseBindMatricesArray ? Array.from(inverseBindMatricesArray) : undefined,
+            binaryData: (_fbGeometryData_binaryDataArray = fbGeometryData.binaryDataArray()) != null ? _fbGeometryData_binaryDataArray : undefined,
+            id: (_fbGeometryData_id = fbGeometryData.id()) != null ? _fbGeometryData_id : "",
+            dataType: DataType.Geometry
+        };
+        return geometryData;
+    };
+    return EffectsPackage;
+}();
+
 /**
  * Engine 基类，负责维护所有 GPU 资源的管理及销毁
  */ var Engine = /*#__PURE__*/ function() {
@@ -25412,16 +26980,23 @@ var listOrder = 0;
         for(var i = 0; i < bins.length; i++){
             var binaryData = bins[i];
             var binaryBuffer = scene.bins[i];
-            //@ts-expect-error
-            binaryData.buffer = binaryBuffer;
-            //@ts-expect-error
-            if (binaryData.id) {
+            if (binaryData.dataType === DataType.BinaryAsset) {
                 //@ts-expect-error
-                this.addEffectsObjectData(binaryData);
+                binaryData.buffer = binaryBuffer;
+                if (binaryData.id) {
+                    this.addEffectsObjectData(binaryData);
+                }
+            } else {
+                var effectsPackage = new EffectsPackage();
+                effectsPackage.deserializeFromBinary(new Uint8Array(binaryBuffer));
+                for(var _iterator7 = _create_for_of_iterator_helper_loose(effectsPackage.exportObjectDatas), _step7; !(_step7 = _iterator7()).done;){
+                    var effectsObjectData = _step7.value;
+                    this.addEffectsObjectData(effectsObjectData);
+                }
             }
         }
-        for(var _iterator7 = _create_for_of_iterator_helper_loose(textureOptions), _step7; !(_step7 = _iterator7()).done;){
-            var textureData = _step7.value;
+        for(var _iterator8 = _create_for_of_iterator_helper_loose(textureOptions), _step8; !(_step8 = _iterator8()).done;){
+            var textureData = _step8.value;
             this.addEffectsObjectData(textureData);
         }
     };
@@ -25731,7 +27306,7 @@ registerPlugin("sprite", SpriteLoader, exports.VFXItem, true);
 registerPlugin("particle", ParticleLoader, exports.VFXItem, true);
 registerPlugin("cal", CalculateLoader, exports.VFXItem, true);
 registerPlugin("interact", InteractLoader, exports.VFXItem, true);
-var version = "2.0.0-alpha.26";
+var version = "2.0.0-alpha.27";
 logger.info("Core version: " + version + ".");
 
 exports.AbstractPlugin = AbstractPlugin;
@@ -25763,6 +27338,7 @@ exports.EVENT_TYPE_TOUCH_END = EVENT_TYPE_TOUCH_END;
 exports.EVENT_TYPE_TOUCH_MOVE = EVENT_TYPE_TOUCH_MOVE;
 exports.EVENT_TYPE_TOUCH_START = EVENT_TYPE_TOUCH_START;
 exports.EffectsObject = EffectsObject;
+exports.EffectsPackage = EffectsPackage;
 exports.Engine = Engine;
 exports.EventSystem = EventSystem;
 exports.Float16ArrayWrapper = Float16ArrayWrapper;