@galacean/engine-loader 1.0.0-alpha.6 → 1.0.0

package/dist/module.js

@@ -1,56 +1,39 @@
-import { resourceLoader, AssetType, AssetPromise, AnimatorController, AnimatorControllerLayer, AnimatorStateMachine, Loader, AnimatorStateTransition, TextureCube, TextureFilterMode, TextureCubeFace, AmbientLight, DiffuseMode, Font, request, ContentRestorer, IndexFormat, VertexElementFormat, AnimationClip, InterpolationType, AnimationFloatArrayCurve, Keyframe, AnimationQuaternionCurve, AnimationVector3Curve, SkinnedMeshRenderer, Transform, Entity, PBRMaterial, Logger, PBRSpecularMaterial, TextureCoordinate, RenderFace, VertexElement, Buffer, BufferBindFlag, BufferUsage, BlendShape, ModelMesh, Camera, MeshRenderer, Animator, BlinnPhongMaterial, Skin, TextureWrapMode as TextureWrapMode$1, Texture2D, EngineObject, TextureFormat, PBRBaseMaterial, Shader, UnlitMaterial, DirectLight, ParticleRenderer, PointLight, SpotLight, Script, SpriteMask, SpriteRenderer, TextRenderer, AnimationEvent, AnimationColorCurve, AnimationVector4Curve, AnimationVector2Curve, AnimationArrayCurve, AnimationFloatCurve, Scene, SpriteAtlas, Sprite, BackgroundMode, SkyBoxMaterial, PrimitiveMesh } from '@galacean/engine-core';
+import { resourceLoader, AssetType, AssetPromise, AnimatorController, AnimatorControllerLayer, AnimatorStateMachine, AnimatorStateTransition, Loader, TextureCube, TextureFilterMode, TextureCubeFace, AmbientLight, DiffuseMode, Font, IndexFormat, VertexElementFormat, DirectLight, PointLight, SpotLight, PBRMaterial, TextureCoordinate, Logger, RenderFace, PBRSpecularMaterial, UnlitMaterial, AnimationClip, InterpolationType, AnimationFloatArrayCurve, Keyframe, AnimationQuaternionCurve, AnimationVector3Curve, SkinnedMeshRenderer, Transform, request, Entity, VertexElement, Buffer, BufferBindFlag, BufferUsage, BlendShape, ModelMesh, Camera, Animator, BlinnPhongMaterial, MeshRenderer, Skin, TextureWrapMode as TextureWrapMode$1, Texture2D, EngineObject, TextureFormat, PBRBaseMaterial, Shader, ParticleRenderer, Script, SpriteMask, SpriteRenderer, TextRenderer, AnimationEvent, AnimationColorCurve, AnimationVector4Curve, AnimationVector2Curve, AnimationArrayCurve, AnimationFloatCurve, Scene, SpriteAtlas, Sprite, BackgroundMode, SkyBoxMaterial, PrimitiveMesh } from '@galacean/engine-core';
 import { SphericalHarmonics3, Vector2, Vector3, Vector4, Color, Quaternion, Matrix, Rect } from '@galacean/engine-math';
-import { GLCompressedTextureInternalFormat } from '@galacean/engine-rhi-webgl';
 import { DRACODecoder } from '@galacean/engine-draco';
+import { GLCompressedTextureInternalFormat } from '@galacean/engine-rhi-webgl';
 
-function extends_() {
-  extends_ = Object.assign || function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
         }
-      }
-    }
-
-    return target;
-  };
 
-  return extends_.apply(this, arguments);
-}
+        return target;
+    };
 
-function _extends() {
-  return extends_.apply(this, arguments);
+    return _extends.apply(this, arguments);
 }
 
-function setPrototypeOf(o, p) {
-  setPrototypeOf = Object.setPrototypeOf || function setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
 
-  return setPrototypeOf(o, p);
-}
+        return o;
+    };
 
-function _setPrototypeOf(o, p) {
-  return setPrototypeOf(o, p);
+    return _set_prototype_of(o, p);
 }
 
 function _inherits(subClass, superClass) {
-  if (typeof superClass !== "function" && superClass !== null) {
-    throw new TypeError("Super expression must either be null or a function");
-  }
-
-  subClass.prototype = Object.create(superClass && superClass.prototype, {
-    constructor: {
-      value: subClass,
-      writable: true,
-      configurable: true
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
     }
-  });
-  if (superClass) _setPrototypeOf(subClass, superClass);
+
+    subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+
+    if (superClass) _set_prototype_of(subClass, superClass);
 }
 
 /******************************************************************************
@@ -103,10 +86,10 @@ function __generator(thisArg, body) {
     }
 }
 
-var AnimatorControllerLoader = /*#__PURE__*/ function(Loader1) {
-    _inherits(AnimatorControllerLoader, Loader1);
+var AnimatorControllerLoader = /*#__PURE__*/ function(Loader) {
+    _inherits(AnimatorControllerLoader, Loader);
     function AnimatorControllerLoader() {
-        return Loader1.apply(this, arguments);
+        return Loader.apply(this, arguments);
     }
     var _proto = AnimatorControllerLoader.prototype;
     _proto.load = function load(item, resourceManager) {
@@ -127,16 +110,13 @@ var AnimatorControllerLoader = /*#__PURE__*/ function(Loader1) {
                         var states = stateMachineData.states;
                         var stateMachine = layer.stateMachine = new AnimatorStateMachine();
                         states.forEach(function(stateData, stateIndex) {
-                            var name = stateData.name, speed = stateData.speed, wrapMode = stateData.wrapMode, clipStartNormalizedTime = stateData.clipStartNormalizedTime, clipEndNormalizedTime = stateData.clipEndNormalizedTime, isDefaultState = stateData.isDefaultState, clipData = stateData.clip, scripts = stateData.scripts;
+                            var name = stateData.name, speed = stateData.speed, wrapMode = stateData.wrapMode, clipStartNormalizedTime = stateData.clipStartNormalizedTime, clipEndNormalizedTime = stateData.clipEndNormalizedTime, isDefaultState = stateData.isDefaultState, clipData = stateData.clip;
                             var state = stateMachine.addState(name);
                             isDefaultState && (stateMachine.defaultState = state);
                             state.speed = speed;
                             state.wrapMode = wrapMode;
                             state.clipStartTime = clipStartNormalizedTime;
                             state.clipEndTime = clipEndNormalizedTime;
-                            scripts == null ? void 0 : scripts.forEach(function(script) {
-                                state.addStateMachineScript(Loader.getClass(script));
-                            });
                             if (clipData) {
                                 promises.push(new Promise(function(resolve) {
                                     //@ts-ignore
@@ -269,39 +249,34 @@ EnvLoader = __decorate([
 ], EnvLoader);
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg);
-    var value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-
-  if (info.done) {
-    resolve(value);
-  } else {
-    Promise.resolve(value).then(_next, _throw);
-  }
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
 }
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
 
-function _asyncToGenerator(fn) {
-  return function () {
-    var self = this,
-      args = arguments;
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args);
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
 
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
 
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
 
-      _next(undefined);
-    });
-  };
+            _next(undefined);
+        });
+    };
 }
 
 var FontLoader = /*#__PURE__*/ function(Loader) {
@@ -334,7 +309,7 @@ var FontLoader = /*#__PURE__*/ function(Loader) {
         });
     };
     _proto._registerFont = function _registerFont(fontName, fontUrl) {
-        return _asyncToGenerator(function() {
+        return _async_to_generator(function() {
             var fontFace;
             return __generator(this, function(_state) {
                 switch(_state.label){
@@ -362,192 +337,52 @@ FontLoader = __decorate([
     ], false)
 ], FontLoader);
 
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-  return arr2;
-}
-
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(n);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
-    return _arrayLikeToArray(o, minLen);
-}
-
-function _createForOfIteratorHelperLoose(o, allowArrayLike) {
-    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-    if (it) return (it = it.call(o)).next.bind(it);
-    // Fallback for engines without symbol support
-    if (
-        Array.isArray(o) ||
-        (it = _unsupportedIterableToArray(o)) ||
-        (allowArrayLike && o && typeof o.length === "number")
-    ) {
-        if (it) o = it;
-        var i = 0;
-        return function () {
-            if (i >= o.length) return { done: true };
-            return { done: false, value: o[i++] };
-        }
-    }
-    throw new TypeError("Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
 /**
  * @internal
- */ var GLTFContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
-    _inherits(GLTFContentRestorer, ContentRestorer);
-    function GLTFContentRestorer() {
-        var _this;
-        _this = ContentRestorer.apply(this, arguments) || this;
-        _this.bufferRequests = [];
-        _this.glbBufferSlices = [];
-        _this.bufferTextures = [];
-        _this.meshes = [];
-        return _this;
+ */ var ParserContext = /*#__PURE__*/ function() {
+    function ParserContext(url) {
+        this.hasSkinned = false;
+        /** chain asset promise */ this.chainPromises = [];
+        this.accessorBufferCache = {};
+        this.texturesPromiseInfo = new PromiseInfo();
+        this.materialsPromiseInfo = new PromiseInfo();
+        this.meshesPromiseInfo = new PromiseInfo();
+        this.animationClipsPromiseInfo = new PromiseInfo();
+        this.defaultSceneRootPromiseInfo = new PromiseInfo();
+        this.masterPromiseInfo = new PromiseInfo();
+        this.promiseMap = {};
+        var promiseMap = this.promiseMap;
+        promiseMap["" + url + "?q=textures"] = this._initPromiseInfo(this.texturesPromiseInfo);
+        promiseMap["" + url + "?q=materials"] = this._initPromiseInfo(this.materialsPromiseInfo);
+        promiseMap["" + url + "?q=meshes"] = this._initPromiseInfo(this.meshesPromiseInfo);
+        promiseMap["" + url + "?q=animations"] = this._initPromiseInfo(this.animationClipsPromiseInfo);
+        promiseMap["" + url + "?q=defaultSceneRoot"] = this._initPromiseInfo(this.defaultSceneRootPromiseInfo);
+        promiseMap["" + url] = this._initPromiseInfo(this.masterPromiseInfo);
     }
-    var _proto = GLTFContentRestorer.prototype;
-    /**
-   * @override
-   */ _proto.restoreContent = function restoreContent() {
-        var _this = this;
-        return new AssetPromise(function(resolve, reject) {
-            Promise.all(_this.bufferRequests.map(function(bufferRequestInfo) {
-                return request(bufferRequestInfo.url, bufferRequestInfo.config);
-            })).then(function(buffers) {
-                // Buffer parse
-                if (_this.isGLB) {
-                    var glbBufferSlice = _this.glbBufferSlices;
-                    var bigBuffer = buffers[0];
-                    var bufferCount = glbBufferSlice.length;
-                    buffers.length = bufferCount;
-                    for(var i = 0; i < bufferCount; i++){
-                        var slice = glbBufferSlice[i];
-                        buffers[i] = bigBuffer.slice(slice.x, slice.x + slice.y);
-                    }
-                }
-                // Restore texture
-                AssetPromise.all(_this.bufferTextures.map(function(textureRestoreInfo) {
-                    var bufferView = textureRestoreInfo.bufferView;
-                    var buffer = buffers[bufferView.buffer];
-                    var _bufferView_byteOffset;
-                    var bufferData = new Uint8Array(buffer, (_bufferView_byteOffset = bufferView.byteOffset) != null ? _bufferView_byteOffset : 0, bufferView.byteLength);
-                    return GLTFUtil.loadImageBuffer(bufferData, textureRestoreInfo.mimeType).then(function(image) {
-                        textureRestoreInfo.texture.setImageSource(image);
-                        textureRestoreInfo.texture.generateMipmaps();
-                    });
-                })).then(function() {
-                    // Restore mesh
-                    for(var _iterator = _createForOfIteratorHelperLoose(_this.meshes), _step; !(_step = _iterator()).done;){
-                        var meshInfo = _step.value;
-                        var mesh = meshInfo.mesh;
-                        for(var _iterator1 = _createForOfIteratorHelperLoose(meshInfo.vertexBuffers), _step1; !(_step1 = _iterator1()).done;){
-                            var bufferRestoreInfo = _step1.value;
-                            var vertexData = _this._getBufferData(buffers, bufferRestoreInfo.data);
-                            bufferRestoreInfo.buffer.setData(vertexData);
-                        }
-                        if (meshInfo.indexBuffer) {
-                            var indexData = _this._getBufferData(buffers, meshInfo.indexBuffer);
-                            mesh.setIndices(indexData);
-                        }
-                        for(var _iterator2 = _createForOfIteratorHelperLoose(meshInfo.blendShapes), _step2; !(_step2 = _iterator2()).done;){
-                            var restoreInfo = _step2.value;
-                            var frame = restoreInfo.blendShape.frames[0];
-                            var positionData = _this._getBufferData(buffers, restoreInfo.position);
-                            frame.deltaPositions = GLTFUtil.floatBufferToVector3Array(positionData);
-                            if (restoreInfo.normal) {
-                                var normalData = _this._getBufferData(buffers, restoreInfo.normal);
-                                frame.deltaNormals = GLTFUtil.floatBufferToVector3Array(normalData);
-                            }
-                            if (restoreInfo.tangent) {
-                                var tangentData = _this._getBufferData(buffers, restoreInfo.tangent);
-                                frame.deltaTangents = GLTFUtil.floatBufferToVector3Array(tangentData);
-                            }
-                        }
-                        mesh.uploadData(true);
-                    }
-                    resolve(_this.resource);
-                }).catch(reject);
-            }).catch(reject);
+    var _proto = ParserContext.prototype;
+    _proto._initPromiseInfo = function _initPromiseInfo(promiseInfo) {
+        var promise = new AssetPromise(function(resolve, reject, setProgress, onCancel) {
+            promiseInfo.resolve = resolve;
+            promiseInfo.reject = reject;
+            promiseInfo.setProgress = setProgress;
+            promiseInfo.onCancel = onCancel;
         });
+        promiseInfo.promise = promise;
+        return promise;
     };
-    _proto._getBufferData = function _getBufferData(buffers, restoreInfo) {
-        var main = restoreInfo.main;
-        var buffer = buffers[main.bufferIndex];
-        var data = new main.TypedArray(buffer, main.byteOffset, main.length);
-        var sparseCount = restoreInfo.sparseCount;
-        if (sparseCount) {
-            var sparseIndex = restoreInfo.sparseIndices;
-            var sparseIndexBuffer = buffers[sparseIndex.bufferIndex];
-            var sparseIndexData = new sparseIndex.TypedArray(sparseIndexBuffer, sparseIndex.byteOffset, sparseIndex.length);
-            var sparseValue = restoreInfo.sparseValues;
-            var sparseValueBuffer = buffers[sparseValue.bufferIndex];
-            var sparseValueData = new sparseValue.TypedArray(sparseValueBuffer, sparseValue.byteOffset, sparseValue.length);
-            var typeSize = restoreInfo.typeSize;
-            for(var i = 0; i < sparseCount; i++){
-                var replaceIndex = sparseIndexData[i];
-                for(var j = 0; j < typeSize; j++){
-                    data[replaceIndex * typeSize + j] = sparseValueData[i * typeSize + j];
-                }
-            }
-        }
-        return data;
-    };
-    return GLTFContentRestorer;
-}(ContentRestorer);
-/**
- * @internal
- */ var BufferRequestInfo = function BufferRequestInfo(url, config) {
-    this.url = url;
-    this.config = config;
-};
-/**
- * @internal
- */ var BufferTextureRestoreInfo = function BufferTextureRestoreInfo(texture, bufferView, mimeType) {
-    this.texture = texture;
-    this.bufferView = bufferView;
-    this.mimeType = mimeType;
-};
-/**
- * @internal
- */ var ModelMeshRestoreInfo = function ModelMeshRestoreInfo() {
-    this.vertexBuffers = [];
-    this.blendShapes = [];
-};
+    return ParserContext;
+}();
 /**
  * @internal
- */ var BufferRestoreInfo = function BufferRestoreInfo(buffer, data) {
-    this.buffer = buffer;
+ */ var BufferInfo = function BufferInfo(data, interleaved, stride) {
     this.data = data;
+    this.interleaved = interleaved;
+    this.stride = stride;
+    this.vertexBindingInfos = {};
 };
 /**
  * @internal
- */ var BufferDataRestoreInfo = function BufferDataRestoreInfo(main, typeSize, sparseCount, sparseIndices, sparseValues) {
-    this.main = main;
-    this.typeSize = typeSize;
-    this.sparseCount = sparseCount;
-    this.sparseIndices = sparseIndices;
-    this.sparseValues = sparseValues;
-};
-/**
- * @internal
- */ var RestoreDataAccessor = function RestoreDataAccessor(bufferIndex, TypedArray, byteOffset, length) {
-    this.bufferIndex = bufferIndex;
-    this.TypedArray = TypedArray;
-    this.byteOffset = byteOffset;
-    this.length = length;
-};
-/**
- * @internal
- */ var BlendShapeRestoreInfo = function BlendShapeRestoreInfo(blendShape, position, normal, tangent) {
-    this.blendShape = blendShape;
-    this.position = position;
-    this.normal = normal;
-    this.tangent = tangent;
+ */ var PromiseInfo = function PromiseInfo() {
 };
 
 /**
@@ -697,54 +532,6 @@ var TextureWrapMode;
    */ "REPEAT"] = 10497] = "REPEAT";
 })(TextureWrapMode || (TextureWrapMode = {}));
 
-/**
- * @internal
- */ var GLTFParserContext = /*#__PURE__*/ function() {
-    function GLTFParserContext(url) {
-        this.hasSkinned = false;
-        this.chainPromises = [];
-        this.accessorBufferCache = {};
-        this.texturesPromiseInfo = new PromiseInfo();
-        this.materialsPromiseInfo = new PromiseInfo();
-        this.meshesPromiseInfo = new PromiseInfo();
-        this.animationClipsPromiseInfo = new PromiseInfo();
-        this.defaultSceneRootPromiseInfo = new PromiseInfo();
-        this.masterPromiseInfo = new PromiseInfo();
-        this.promiseMap = {};
-        var promiseMap = this.promiseMap;
-        promiseMap["" + url + "?q=textures"] = this._initPromiseInfo(this.texturesPromiseInfo);
-        promiseMap["" + url + "?q=materials"] = this._initPromiseInfo(this.materialsPromiseInfo);
-        promiseMap["" + url + "?q=meshes"] = this._initPromiseInfo(this.meshesPromiseInfo);
-        promiseMap["" + url + "?q=animations"] = this._initPromiseInfo(this.animationClipsPromiseInfo);
-        promiseMap["" + url + "?q=defaultSceneRoot"] = this._initPromiseInfo(this.defaultSceneRootPromiseInfo);
-        promiseMap["" + url] = this._initPromiseInfo(this.masterPromiseInfo);
-    }
-    var _proto = GLTFParserContext.prototype;
-    _proto._initPromiseInfo = function _initPromiseInfo(promiseInfo) {
-        var promise = new AssetPromise(function(resolve, reject, setProgress, onCancel) {
-            promiseInfo.resolve = resolve;
-            promiseInfo.reject = reject;
-            promiseInfo.setProgress = setProgress;
-            promiseInfo.onCancel = onCancel;
-        });
-        promiseInfo.promise = promise;
-        return promise;
-    };
-    return GLTFParserContext;
-}();
-/**
- * @internal
- */ var BufferInfo = function BufferInfo(data, interleaved, stride) {
-    this.data = data;
-    this.interleaved = interleaved;
-    this.stride = stride;
-    this.vertexBindingInfos = {};
-};
-/**
- * @internal
- */ var PromiseInfo = function PromiseInfo() {
-};
-
 /**
  * @internal
  */ var GLTFUtil = /*#__PURE__*/ function() {
@@ -853,18 +640,18 @@ var TextureWrapMode;
                 throw new Error("Galacean.GLTFLoader: Unsupported normalized accessor component type.");
         }
     };
-    GLTFUtil.getAccessorBuffer = function getAccessorBuffer(context, bufferViews, accessor) {
+    GLTFUtil.getAccessorBuffer = function getAccessorBuffer(context, gltf, accessor) {
         var buffers = context.buffers;
+        var bufferViews = gltf.bufferViews;
         var componentType = accessor.componentType;
         var bufferView = bufferViews[accessor.bufferView];
-        var bufferIndex = bufferView.buffer;
-        var buffer = buffers[bufferIndex];
+        var buffer = buffers[bufferView.buffer];
         var bufferByteOffset = bufferView.byteOffset || 0;
         var byteOffset = accessor.byteOffset || 0;
         var TypedArray = GLTFUtil.getComponentType(componentType);
-        var dataElementSize = GLTFUtil.getAccessorTypeSize(accessor.type);
+        var dataElmentSize = GLTFUtil.getAccessorTypeSize(accessor.type);
         var dataElementBytes = TypedArray.BYTES_PER_ELEMENT;
-        var elementStride = dataElementSize * dataElementBytes;
+        var elementStride = dataElmentSize * dataElementBytes;
         var accessorCount = accessor.count;
         var bufferStride = bufferView.byteStride;
         var bufferInfo;
@@ -879,25 +666,24 @@ var TextureWrapMode;
                 var count = accessorCount * (bufferStride / dataElementBytes);
                 var data = new TypedArray(buffer, offset, count);
                 accessorBufferCache[bufferCacheKey] = bufferInfo = new BufferInfo(data, true, bufferStride);
-                bufferInfo.restoreInfo = new BufferDataRestoreInfo(new RestoreDataAccessor(bufferIndex, TypedArray, offset, count));
             }
         } else {
             var offset1 = bufferByteOffset + byteOffset;
-            var count1 = accessorCount * dataElementSize;
+            var count1 = accessorCount * dataElmentSize;
             var data1 = new TypedArray(buffer, offset1, count1);
             bufferInfo = new BufferInfo(data1, false, elementStride);
-            bufferInfo.restoreInfo = new BufferDataRestoreInfo(new RestoreDataAccessor(bufferIndex, TypedArray, offset1, count1));
         }
         if (accessor.sparse) {
-            GLTFUtil.processingSparseData(bufferViews, accessor, buffers, bufferInfo);
+            var data2 = GLTFUtil.processingSparseData(gltf, accessor, buffers, bufferInfo.data);
+            bufferInfo = new BufferInfo(data2, false, bufferInfo.stride);
         }
         return bufferInfo;
     };
     /**
    * @deprecated
    * Get accessor data.
-   */ GLTFUtil.getAccessorData = function getAccessorData(glTF, accessor, buffers) {
-        var bufferViews = glTF.bufferViews;
+   */ GLTFUtil.getAccessorData = function getAccessorData(gltf, accessor, buffers) {
+        var bufferViews = gltf.bufferViews;
         var bufferView = bufferViews[accessor.bufferView];
         var arrayBuffer = buffers[bufferView.buffer];
         var accessorByteOffset = accessor.hasOwnProperty("byteOffset") ? accessor.byteOffset : 0;
@@ -947,46 +733,38 @@ var TextureWrapMode;
         return typedArray;
     };
     GLTFUtil.getBufferViewData = function getBufferViewData(bufferView, buffers) {
-        var _bufferView_byteOffset = bufferView.byteOffset, byteOffset = _bufferView_byteOffset === void 0 ? 0 : _bufferView_byteOffset;
-        var arrayBuffer = buffers[bufferView.buffer];
-        return arrayBuffer.slice(byteOffset, byteOffset + bufferView.byteLength);
+        var buffer = bufferView.buffer, _bufferView_byteOffset = bufferView.byteOffset, byteOffset = _bufferView_byteOffset === void 0 ? 0 : _bufferView_byteOffset, byteLength = bufferView.byteLength;
+        var arrayBuffer = buffers[buffer];
+        return arrayBuffer.slice(byteOffset, byteOffset + byteLength);
     };
     /**
    * Get accessor data.
-   */ GLTFUtil.processingSparseData = function processingSparseData(bufferViews, accessor, buffers, bufferInfo) {
-        var restoreInfo = bufferInfo.restoreInfo;
+   */ GLTFUtil.processingSparseData = function processingSparseData(gltf, accessor, buffers, originData) {
+        var bufferViews = gltf.bufferViews;
         var accessorTypeSize = GLTFUtil.getAccessorTypeSize(accessor.type);
         var TypedArray = GLTFUtil.getComponentType(accessor.componentType);
-        var data = bufferInfo.data.slice();
+        var data = originData.slice();
         var _accessor_sparse = accessor.sparse, count = _accessor_sparse.count, indices = _accessor_sparse.indices, values = _accessor_sparse.values;
         var indicesBufferView = bufferViews[indices.bufferView];
         var valuesBufferView = bufferViews[values.bufferView];
-        var indicesBufferIndex = indicesBufferView.buffer;
-        var valuesBufferIndex = valuesBufferView.buffer;
-        var indicesArrayBuffer = buffers[indicesBufferIndex];
-        var valuesArrayBuffer = buffers[valuesBufferIndex];
+        var indicesArrayBuffer = buffers[indicesBufferView.buffer];
+        var valuesArrayBuffer = buffers[valuesBufferView.buffer];
         var _indices_byteOffset, _indicesBufferView_byteOffset;
         var indicesByteOffset = ((_indices_byteOffset = indices.byteOffset) != null ? _indices_byteOffset : 0) + ((_indicesBufferView_byteOffset = indicesBufferView.byteOffset) != null ? _indicesBufferView_byteOffset : 0);
         var indicesByteLength = indicesBufferView.byteLength;
         var _values_byteOffset, _valuesBufferView_byteOffset;
         var valuesByteOffset = ((_values_byteOffset = values.byteOffset) != null ? _values_byteOffset : 0) + ((_valuesBufferView_byteOffset = valuesBufferView.byteOffset) != null ? _valuesBufferView_byteOffset : 0);
         var valuesByteLength = valuesBufferView.byteLength;
-        restoreInfo.typeSize = accessorTypeSize;
-        restoreInfo.sparseCount = count;
         var IndexTypeArray = GLTFUtil.getComponentType(indices.componentType);
-        var indexLength = indicesByteLength / IndexTypeArray.BYTES_PER_ELEMENT;
-        var indicesArray = new IndexTypeArray(indicesArrayBuffer, indicesByteOffset, indexLength);
-        restoreInfo.sparseIndices = new RestoreDataAccessor(indicesBufferIndex, IndexTypeArray, indicesByteOffset, indexLength);
-        var valueLength = valuesByteLength / TypedArray.BYTES_PER_ELEMENT;
-        var valuesArray = new TypedArray(valuesArrayBuffer, valuesByteOffset, valueLength);
-        restoreInfo.sparseValues = new RestoreDataAccessor(valuesBufferIndex, TypedArray, valuesByteOffset, valueLength);
+        var indicesArray = new IndexTypeArray(indicesArrayBuffer, indicesByteOffset, indicesByteLength / IndexTypeArray.BYTES_PER_ELEMENT);
+        var valuesArray = new TypedArray(valuesArrayBuffer, valuesByteOffset, valuesByteLength / TypedArray.BYTES_PER_ELEMENT);
         for(var i = 0; i < count; i++){
             var replaceIndex = indicesArray[i];
             for(var j = 0; j < accessorTypeSize; j++){
                 data[replaceIndex * accessorTypeSize + j] = valuesArray[i * accessorTypeSize + j];
             }
         }
-        bufferInfo.data = data;
+        return data;
     };
     GLTFUtil.getIndexFormat = function getIndexFormat(type) {
         switch(type){
@@ -1084,7 +862,7 @@ var TextureWrapMode;
     };
     /**
    * Parse the glb format.
-   */ GLTFUtil.parseGLB = function parseGLB(context, glb) {
+   */ GLTFUtil.parseGLB = function parseGLB(glb) {
         var UINT32_LENGTH = 4;
         var GLB_HEADER_MAGIC = 0x46546c67; // 'glTF'
         var GLB_HEADER_LENGTH = 12;
@@ -1112,11 +890,10 @@ var TextureWrapMode;
             return null;
         }
         var glTFData = new Uint8Array(glb, GLB_HEADER_LENGTH + 2 * UINT32_LENGTH, chunkLength);
-        var glTF = JSON.parse(GLTFUtil.decodeText(glTFData));
+        var gltf = JSON.parse(GLTFUtil.decodeText(glTFData));
         // read all buffers
         var buffers = [];
         var byteOffset = GLB_HEADER_LENGTH + 2 * UINT32_LENGTH + chunkLength;
-        var restoreGLBBufferSlice = context.contentRestorer.glbBufferSlices;
         while(byteOffset < header.length){
             chunkLength = dataView.getUint32(byteOffset, true);
             chunkType = dataView.getUint32(byteOffset + UINT32_LENGTH, true);
@@ -1127,11 +904,10 @@ var TextureWrapMode;
             var currentOffset = byteOffset + 2 * UINT32_LENGTH;
             var buffer = glb.slice(currentOffset, currentOffset + chunkLength);
             buffers.push(buffer);
-            restoreGLBBufferSlice.push(new Vector2(currentOffset, chunkLength));
             byteOffset += chunkLength + 2 * UINT32_LENGTH;
         }
         return {
-            glTF: glTF,
+            gltf: gltf,
             buffers: buffers
         };
     };
@@ -1146,339 +922,630 @@ var TextureWrapMode;
     return GLTFUtil;
 }();
 
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+    return arr2;
 }
 
-function _iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
 }
 
-function _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
 }
 
-function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 
-/**
- * Base class of glTF extension parser.
- */ var GLTFExtensionParser = /*#__PURE__*/ function() {
-    function GLTFExtensionParser() {}
-    var _proto = GLTFExtensionParser.prototype;
-    /**
-   * Initialize the parser.
-   * @remarks Some plugins require initialization.
-   * @returns The void or promise
-   */ _proto.initialize = function initialize() {};
-    /**
-   * Create and parse the resource.
-   * @remarks This method overrides the default resource creation.
-   * @param context - The parser context
-   * @param extensionSchema - The extension schema
-   * @param extensionOwnerSchema - The extension owner schema
-   * @returns The resource or promise
-   */ _proto.createAndParse = function createAndParse(context, extensionSchema, extensionOwnerSchema) {
-        for(var _len = arguments.length, extra = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++){
-            extra[_key - 3] = arguments[_key];
-        }
-        throw "Not implemented.";
-    };
-    /**
-   * Additive parse to the resource.
-   * @param context - The parser context
-   * @param parseResource - The parsed resource
-   * @param extensionSchema - The extension schema
-   * @param extensionOwnerSchema - The extension owner schema
-   * @returns The void or promise
-   */ _proto.additiveParse = function additiveParse(context, parseResource, extensionSchema, extensionOwnerSchema) {
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+
+var Parser = /*#__PURE__*/ function() {
+    function Parser() {}
+    Parser.parseEngineResource = function parseEngineResource(extensionName, extensionSchema, parseResource, context) {
         for(var _len = arguments.length, extra = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++){
             extra[_key - 4] = arguments[_key];
         }
-        throw "Not implemented.";
-    };
-    return GLTFExtensionParser;
-}();
-var GLTFExtensionMode;
-(function(GLTFExtensionMode) {
-    GLTFExtensionMode[GLTFExtensionMode[/**
-   * Cerate instance and parse mode.
-   * @remarks
-   * If the glTF property has multiple extensions of `CreateAndParse` mode, only execute the last one.
-   * If this method is registered, the default pipeline processing will be ignored.
-   */ "CreateAndParse"] = 0] = "CreateAndParse";
-    GLTFExtensionMode[GLTFExtensionMode[/** Additive parse mode. */ "AdditiveParse"] = 1] = "AdditiveParse";
-})(GLTFExtensionMode || (GLTFExtensionMode = {}));
-
-/**
- * Base class of glTF parser.
- */ var GLTFParser = /*#__PURE__*/ function() {
-    function GLTFParser() {}
-    /**
-   * Execute all parses of extension to initialize plugin.
-   * @remarks Some plugins require initialization.
-   * @returns The void or promise
-   */ GLTFParser.executeExtensionsInitialize = function executeExtensionsInitialize(extensionName) {
-        var parsers = GLTFParser._extensionParsers[extensionName];
-        var length = parsers == null ? void 0 : parsers.length;
-        if (length) {
-            return parsers[length - 1].initialize();
+        var parsers = Parser._extensionParsers[extensionName];
+        if (parsers == null ? void 0 : parsers.length) {
+            for(var i = 0; i < parsers.length; i++){
+                var _parsers_i;
+                (_parsers_i = parsers[i]).parseEngineResource.apply(_parsers_i, [
+                    extensionSchema,
+                    parseResource,
+                    context
+                ].concat(_to_consumable_array(extra)));
+            }
         }
     };
-    /**
-   * Execute all parses of extension to create resource.
-   * @param extensions - Related extensions field
-   * @param context - The parser context
-   * @param ownerSchema - The extension owner schema
-   * @param extra - Extra params
-   * @returns
-   */ GLTFParser.executeExtensionsCreateAndParse = function executeExtensionsCreateAndParse(extensions, context, ownerSchema) {
-        if (extensions === void 0) extensions = {};
+    Parser.createEngineResource = function createEngineResource(extensionName, extensionSchema, context) {
         for(var _len = arguments.length, extra = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++){
             extra[_key - 3] = arguments[_key];
         }
-        var resource = null;
-        var extensionArray = Object.keys(extensions);
-        for(var i = extensionArray.length - 1; i >= 0; --i){
-            var _GLTFParser;
-            var extensionName = extensionArray[i];
-            var extensionSchema = extensions[extensionName];
-            resource = (_GLTFParser = GLTFParser)._createAndParse.apply(_GLTFParser, [
-                extensionName,
-                context,
+        var parsers = Parser._extensionParsers[extensionName];
+        if (parsers == null ? void 0 : parsers.length) {
+            var _parsers_;
+            return (_parsers_ = parsers[0]).createEngineResource.apply(_parsers_, [
                 extensionSchema,
-                ownerSchema
-            ].concat(_toConsumableArray(extra)));
-            if (resource) {
-                return resource;
-            }
-        }
-    };
-    /**
-   * Execute all parses of extension to parse resource.
-   * @param extensions - Related extensions field
-   * @param context - The parser context
-   * @param parseResource -  The parsed resource
-   * @param ownerSchema - The extension owner schema
-   * @param extra - Extra params
-   */ GLTFParser.executeExtensionsAdditiveAndParse = function executeExtensionsAdditiveAndParse(extensions, context, parseResource, ownerSchema) {
-        for(var _len = arguments.length, extra = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++){
-            extra[_key - 4] = arguments[_key];
-        }
-        for(var extensionName in extensions){
-            var _GLTFParser;
-            var extensionSchema = extensions[extensionName];
-            (_GLTFParser = GLTFParser)._additiveParse.apply(_GLTFParser, [
-                extensionName,
-                context,
-                parseResource,
-                extensionSchema,
-                ownerSchema
-            ].concat(_toConsumableArray(extra)));
+                context
+            ].concat(_to_consumable_array(extra)));
         }
     };
-    /**
-   * Whether the plugin is registered.
-   * @param extensionName - Extension name
-   * @returns Boolean
-   */ GLTFParser.hasExtensionParser = function hasExtensionParser(extensionName) {
-        var _GLTFParser__extensionParsers_extensionName;
-        return !!((_GLTFParser__extensionParsers_extensionName = GLTFParser._extensionParsers[extensionName]) == null ? void 0 : _GLTFParser__extensionParsers_extensionName.length);
+    Parser.hasExtensionParser = function hasExtensionParser(extensionName) {
+        var parsers = Parser._extensionParsers[extensionName];
+        return !!(parsers == null ? void 0 : parsers.length);
     };
-    /**
-   * Get the last plugin by glTF extension mode.
-   * @param extensionName - Extension name
-   * @param mode - GLTF extension mode
-   * @returns GLTF extension parser
-   */ GLTFParser.getExtensionParser = function getExtensionParser(extensionName, mode) {
-        var parsers = GLTFParser._extensionParsers[extensionName];
-        var length = parsers == null ? void 0 : parsers.length;
-        if (length) {
-            // only use the last parser.
-            for(var i = length - 1; i >= 0; --i){
-                var currentParser = parsers[i];
-                if (currentParser._mode === mode) {
-                    return currentParser;
-                }
+    Parser.initialize = function initialize(extensionName) {
+        var parsers = Parser._extensionParsers[extensionName];
+        if (parsers == null ? void 0 : parsers.length) {
+            for(var i = 0; i < parsers.length; i++){
+                parsers[i].initialize();
             }
         }
     };
     /**
    * @internal
-   */ GLTFParser._addExtensionParser = function _addExtensionParser(extensionName, extensionParser) {
-        if (!GLTFParser._extensionParsers[extensionName]) {
-            GLTFParser._extensionParsers[extensionName] = [];
-        }
-        GLTFParser._extensionParsers[extensionName].push(extensionParser);
-    };
-    GLTFParser._createAndParse = function _createAndParse(extensionName, context, extensionSchema, ownerSchema) {
-        for(var _len = arguments.length, extra = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++){
-            extra[_key - 4] = arguments[_key];
-        }
-        var parser = GLTFParser.getExtensionParser(extensionName, GLTFExtensionMode.CreateAndParse);
-        if (parser) {
-            var _parser;
-            return (_parser = parser).createAndParse.apply(_parser, [
-                context,
-                extensionSchema,
-                ownerSchema
-            ].concat(_toConsumableArray(extra)));
-        }
-    };
-    GLTFParser._additiveParse = function _additiveParse(extensionName, context, parseResource, extensionSchema, ownerSchema) {
-        for(var _len = arguments.length, extra = new Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++){
-            extra[_key - 5] = arguments[_key];
-        }
-        var parser = GLTFParser.getExtensionParser(extensionName, GLTFExtensionMode.AdditiveParse);
-        if (parser) {
-            var _parser;
-            (_parser = parser).additiveParse.apply(_parser, [
-                context,
-                parseResource,
-                extensionSchema,
-                ownerSchema
-            ].concat(_toConsumableArray(extra)));
+   */ Parser._addExtensionParser = function _addExtensionParser(extensionName, extensionParser) {
+        if (!Parser._extensionParsers[extensionName]) {
+            Parser._extensionParsers[extensionName] = [];
         }
+        Parser._extensionParsers[extensionName].push(extensionParser);
     };
-    return GLTFParser;
+    return Parser;
 }();
-GLTFParser._extensionParsers = {};
+(function() {
+    Parser._extensionParsers = {};
+})();
 /**
  * Declare ExtensionParser's decorator.
  * @param extensionName - Extension name
- */ function registerGLTFExtension(extensionName, mode) {
+ */ function registerExtension(extensionName) {
     return function(parser) {
         var extensionParser = new parser();
-        extensionParser._mode = mode;
-        GLTFParser._addExtensionParser(extensionName, extensionParser);
+        Parser._addExtensionParser(extensionName, extensionParser);
     };
 }
 
-var GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
-    _inherits(GLTFAnimationParser, GLTFParser1);
-    function GLTFAnimationParser() {
-        return GLTFParser1.apply(this, arguments);
-    }
-    var _proto = GLTFAnimationParser.prototype;
-    _proto.parse = function parse(context) {
-        var glTF = context.glTF; context.buffers; var glTFResource = context.glTFResource;
-        glTFResource.entities;
-        var animations = glTF.animations; glTF.accessors; glTF.bufferViews;
-        if (!animations) {
-            return;
+var ExtensionParser = /*#__PURE__*/ function() {
+    function ExtensionParser() {}
+    var _proto = ExtensionParser.prototype;
+    _proto.initialize = function initialize() {};
+    _proto.parseEngineResource = function parseEngineResource(schema, parseResource, context) {
+        for(var _len = arguments.length, extra = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++){
+            extra[_key - 3] = arguments[_key];
         }
-        var animationClipsPromiseInfo = context.animationClipsPromiseInfo;
-        var animationClipCount = animations.length;
-        var animationClipPromises = [];
-        new Array(animationClipCount);
-        for(var i = 0; i < animationClipCount; i++){
-            var animationInfo = animations[i];
-            var _animationInfo_name = animationInfo.name, name = _animationInfo_name === void 0 ? "AnimationClip" + i : _animationInfo_name;
-            var animationClip = GLTFParser.executeExtensionsCreateAndParse(animationInfo.extensions, context, animationInfo);
-            if (!animationClip) {
-                animationClip = new AnimationClip(name);
-                GLTFAnimationParser._parseStandardProperty(context, animationClip, animationInfo);
-            }
-            animationClipPromises.push(animationClip);
+    };
+    _proto.createEngineResource = function createEngineResource(schema, context) {
+        for(var _len = arguments.length, extra = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+            extra[_key - 2] = arguments[_key];
         }
-        return AssetPromise.all(animationClipPromises).then(function(animationClips) {
-            glTFResource.animations = animationClips;
-            for(var i = 0; i < glTF.animations.length; i++){
-                var animationInfo = glTF.animations[i];
-                GLTFParser.executeExtensionsAdditiveAndParse(animationInfo.extensions, context, animationClips[i], animationInfo);
-            }
-            animationClipsPromiseInfo.resolve(animationClips);
-            return animationClipsPromiseInfo.promise;
-        });
+        return null;
     };
-    /**
-   * @internal
-   */ GLTFAnimationParser._parseStandardProperty = function _parseStandardProperty(context, animationClip, animationInfo) {
-        var glTF = context.glTF, glTFResource = context.glTFResource;
-        var entities = glTFResource.entities;
-        var accessors = glTF.accessors, bufferViews = glTF.bufferViews;
-        var channels = animationInfo.channels, samplers = animationInfo.samplers;
-        var sampleDataCollection = new Array();
-        // parse samplers
-        for(var j = 0, m = samplers.length; j < m; j++){
-            var gltfSampler = samplers[j];
-            var inputAccessor = accessors[gltfSampler.input];
-            var outputAccessor = accessors[gltfSampler.output];
-            var input = GLTFUtil.getAccessorBuffer(context, bufferViews, inputAccessor).data;
-            var output = GLTFUtil.getAccessorBuffer(context, bufferViews, outputAccessor).data;
-            if (outputAccessor.normalized) {
-                var scale = GLTFUtil.getNormalizedComponentScale(outputAccessor.componentType);
-                var scaled = new Float32Array(output.length);
-                for(var k = 0, v = output.length; k < v; k++){
-                    scaled[k] = output[k] * scale;
-                }
-                output = scaled;
-            }
-            var outputStride = output.length / input.length;
-            var _gltfSampler_interpolation;
-            var interpolation = (_gltfSampler_interpolation = gltfSampler.interpolation) != null ? _gltfSampler_interpolation : AnimationSamplerInterpolation.Linear;
-            var samplerInterpolation = void 0;
-            switch(interpolation){
-                case AnimationSamplerInterpolation.CubicSpine:
-                    samplerInterpolation = InterpolationType.CubicSpine;
-                    break;
-                case AnimationSamplerInterpolation.Step:
-                    samplerInterpolation = InterpolationType.Step;
-                    break;
-                case AnimationSamplerInterpolation.Linear:
-                    samplerInterpolation = InterpolationType.Linear;
-                    break;
-            }
-            input[input.length - 1];
-            sampleDataCollection.push({
-                type: outputAccessor.type,
-                interpolation: samplerInterpolation,
-                input: input,
-                output: output,
-                outputSize: outputStride
-            });
+    return ExtensionParser;
+}();
+
+var KHR_draco_mesh_compression = /*#__PURE__*/ function(ExtensionParser) {
+    _inherits(KHR_draco_mesh_compression1, ExtensionParser);
+    function KHR_draco_mesh_compression1() {
+        return ExtensionParser.apply(this, arguments);
+    }
+    var _proto = KHR_draco_mesh_compression1.prototype;
+    _proto.initialize = function initialize() {
+        if (!KHR_draco_mesh_compression._decoder) {
+            KHR_draco_mesh_compression._decoder = new DRACODecoder();
         }
-        for(var j1 = 0, m1 = channels.length; j1 < m1; j1++){
-            var gltfChannel = channels[j1];
-            var target = gltfChannel.target;
-            var channelTargetEntity = entities[target.node];
-            var relativePath = "";
-            var entity = channelTargetEntity;
-            while(entity.parent){
-                relativePath = relativePath === "" ? "" + entity.name : entity.name + "/" + relativePath;
-                entity = entity.parent;
-            }
-            var ComponentType = void 0;
-            var propertyName = void 0;
-            switch(target.path){
-                case AnimationChannelTargetPath.TRANSLATION:
-                    ComponentType = Transform;
-                    propertyName = "position";
-                    break;
-                case AnimationChannelTargetPath.ROTATION:
-                    ComponentType = Transform;
-                    propertyName = "rotationQuaternion";
-                    break;
-                case AnimationChannelTargetPath.SCALE:
-                    ComponentType = Transform;
-                    propertyName = "scale";
-                    break;
-                case AnimationChannelTargetPath.WEIGHTS:
-                    ComponentType = SkinnedMeshRenderer;
-                    propertyName = "blendShapeWeights";
-                    break;
+    };
+    _proto.createEngineResource = function createEngineResource(schema, context, gltfPrimitive) {
+        var gltf = context.gltf, buffers = context.buffers;
+        var bufferViews = gltf.bufferViews, accessors = gltf.accessors;
+        var bufferViewIndex = schema.bufferView, gltfAttributeMap = schema.attributes;
+        var attributeMap = {};
+        var attributeTypeMap = {};
+        for(var attributeName in gltfAttributeMap){
+            attributeMap[attributeName] = gltfAttributeMap[attributeName];
+        }
+        for(var attributeName1 in gltfPrimitive.attributes){
+            if (gltfAttributeMap[attributeName1] !== undefined) {
+                var accessorDef = accessors[gltfPrimitive.attributes[attributeName1]];
+                attributeTypeMap[attributeName1] = GLTFUtil.getComponentType(accessorDef.componentType).name;
             }
-            var curve = this._addCurve(target.path, gltfChannel, sampleDataCollection);
-            animationClip.addCurveBinding(relativePath, ComponentType, propertyName, curve);
         }
+        var indexAccessor = accessors[gltfPrimitive.indices];
+        var indexType = GLTFUtil.getComponentType(indexAccessor.componentType).name;
+        var taskConfig = {
+            attributeIDs: attributeMap,
+            attributeTypes: attributeTypeMap,
+            useUniqueIDs: true,
+            indexType: indexType
+        };
+        var buffer = GLTFUtil.getBufferViewData(bufferViews[bufferViewIndex], buffers);
+        return KHR_draco_mesh_compression._decoder.decode(buffer, taskConfig).then(function(parsedGeometry) {
+            return parsedGeometry;
+        });
     };
-    GLTFAnimationParser._addCurve = function _addCurve(animationChannelTargetPath, gltfChannel, sampleDataCollection) {
-        var sampleData = sampleDataCollection[gltfChannel.sampler];
-        var input = sampleData.input, output = sampleData.output, outputSize = sampleData.outputSize;
-        switch(animationChannelTargetPath){
-            case AnimationChannelTargetPath.TRANSLATION:
-            case AnimationChannelTargetPath.SCALE:
+    return KHR_draco_mesh_compression1;
+}(ExtensionParser);
+KHR_draco_mesh_compression = __decorate([
+    registerExtension("KHR_draco_mesh_compression")
+], KHR_draco_mesh_compression);
+
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
+
+var KHR_lights_punctual = /*#__PURE__*/ function(ExtensionParser) {
+    _inherits(KHR_lights_punctual, ExtensionParser);
+    function KHR_lights_punctual() {
+        return ExtensionParser.apply(this, arguments);
+    }
+    var _proto = KHR_lights_punctual.prototype;
+    _proto.parseEngineResource = function parseEngineResource(schema, entity, context) {
+        var color = schema.color, _schema_intensity = schema.intensity, intensity = _schema_intensity === void 0 ? 1 : _schema_intensity, type = schema.type, range = schema.range, spot = schema.spot;
+        var glTFResource = context.glTFResource;
+        var light;
+        if (type === "directional") {
+            light = entity.addComponent(DirectLight);
+        } else if (type === "point") {
+            light = entity.addComponent(PointLight);
+        } else if (type === "spot") {
+            light = entity.addComponent(SpotLight);
+        }
+        if (color) {
+            light.color.set(color[0], color[1], color[2], 1);
+        }
+        light.intensity = intensity;
+        if (range && !_instanceof(light, DirectLight)) {
+            light.distance = range;
+        }
+        if (spot && _instanceof(light, SpotLight)) {
+            var _spot_innerConeAngle = spot.innerConeAngle, innerConeAngle = _spot_innerConeAngle === void 0 ? 0 : _spot_innerConeAngle, _spot_outerConeAngle = spot.outerConeAngle, outerConeAngle = _spot_outerConeAngle === void 0 ? Math.PI / 4 : _spot_outerConeAngle;
+            light.angle = innerConeAngle;
+            light.penumbra = outerConeAngle - innerConeAngle;
+        }
+        if (!glTFResource.lights) glTFResource.lights = [];
+        glTFResource.lights.push(light);
+    };
+    return KHR_lights_punctual;
+}(ExtensionParser);
+KHR_lights_punctual = __decorate([
+    registerExtension("KHR_lights_punctual")
+], KHR_lights_punctual);
+
+var MaterialParser = /*#__PURE__*/ function(Parser1) {
+    _inherits(MaterialParser, Parser1);
+    function MaterialParser() {
+        return Parser1.apply(this, arguments);
+    }
+    var _proto = MaterialParser.prototype;
+    _proto.parse = function parse(context) {
+        var gltf = context.gltf, glTFResource = context.glTFResource;
+        var engine = glTFResource.engine, textures = glTFResource.textures;
+        if (!gltf.materials) return;
+        var materialsPromiseInfo = context.materialsPromiseInfo;
+        var materials = [];
+        for(var i = 0; i < gltf.materials.length; i++){
+            var _gltf_materials_i = gltf.materials[i], _gltf_materials_i_extensions = _gltf_materials_i.extensions, extensions = _gltf_materials_i_extensions === void 0 ? {} : _gltf_materials_i_extensions, pbrMetallicRoughness = _gltf_materials_i.pbrMetallicRoughness, normalTexture = _gltf_materials_i.normalTexture, occlusionTexture = _gltf_materials_i.occlusionTexture, emissiveTexture = _gltf_materials_i.emissiveTexture, emissiveFactor = _gltf_materials_i.emissiveFactor, alphaMode = _gltf_materials_i.alphaMode, alphaCutoff = _gltf_materials_i.alphaCutoff, doubleSided = _gltf_materials_i.doubleSided, _gltf_materials_i_name = _gltf_materials_i.name, name = _gltf_materials_i_name === void 0 ? "" : _gltf_materials_i_name;
+            var KHR_materials_unlit = extensions.KHR_materials_unlit, KHR_materials_pbrSpecularGlossiness = extensions.KHR_materials_pbrSpecularGlossiness, KHR_materials_clearcoat = extensions.KHR_materials_clearcoat, OASIS_materials_remap = extensions.OASIS_materials_remap;
+            var material = null;
+            if (KHR_materials_unlit) {
+                material = Parser.createEngineResource("KHR_materials_unlit", KHR_materials_unlit, context);
+            } else if (KHR_materials_pbrSpecularGlossiness) {
+                material = Parser.createEngineResource("KHR_materials_pbrSpecularGlossiness", KHR_materials_pbrSpecularGlossiness, context);
+            } else {
+                material = new PBRMaterial(engine);
+            }
+            material.name = name;
+            if (KHR_materials_clearcoat) {
+                Parser.parseEngineResource("KHR_materials_clearcoat", KHR_materials_clearcoat, material, context);
+            }
+            if (pbrMetallicRoughness) {
+                var baseColorFactor = pbrMetallicRoughness.baseColorFactor, baseColorTexture = pbrMetallicRoughness.baseColorTexture, metallicFactor = pbrMetallicRoughness.metallicFactor, roughnessFactor = pbrMetallicRoughness.roughnessFactor, metallicRoughnessTexture = pbrMetallicRoughness.metallicRoughnessTexture;
+                if (baseColorFactor) {
+                    material.baseColor = new Color(Color.linearToGammaSpace(baseColorFactor[0]), Color.linearToGammaSpace(baseColorFactor[1]), Color.linearToGammaSpace(baseColorFactor[2]), baseColorFactor[3]);
+                }
+                if (baseColorTexture) {
+                    material.baseTexture = textures[baseColorTexture.index];
+                    MaterialParser._parseTextureTransform(material, baseColorTexture.extensions, context);
+                }
+                if (!KHR_materials_unlit && !KHR_materials_pbrSpecularGlossiness) {
+                    var m = material;
+                    m.metallic = metallicFactor != null ? metallicFactor : 1;
+                    m.roughness = roughnessFactor != null ? roughnessFactor : 1;
+                    if (metallicRoughnessTexture) {
+                        m.roughnessMetallicTexture = textures[metallicRoughnessTexture.index];
+                        MaterialParser._parseTextureTransform(material, metallicRoughnessTexture.extensions, context);
+                    }
+                }
+            }
+            if (!KHR_materials_unlit) {
+                var m1 = material;
+                if (emissiveTexture) {
+                    m1.emissiveTexture = textures[emissiveTexture.index];
+                    MaterialParser._parseTextureTransform(material, emissiveTexture.extensions, context);
+                }
+                if (emissiveFactor) {
+                    m1.emissiveColor = new Color(Color.linearToGammaSpace(emissiveFactor[0]), Color.linearToGammaSpace(emissiveFactor[1]), Color.linearToGammaSpace(emissiveFactor[2]));
+                }
+                if (normalTexture) {
+                    var index = normalTexture.index, scale = normalTexture.scale;
+                    m1.normalTexture = textures[index];
+                    MaterialParser._parseTextureTransform(material, normalTexture.extensions, context);
+                    if (scale !== undefined) {
+                        m1.normalTextureIntensity = scale;
+                    }
+                }
+                if (occlusionTexture) {
+                    var index1 = occlusionTexture.index, strength = occlusionTexture.strength, texCoord = occlusionTexture.texCoord;
+                    m1.occlusionTexture = textures[index1];
+                    MaterialParser._parseTextureTransform(material, occlusionTexture.extensions, context);
+                    if (strength !== undefined) {
+                        m1.occlusionTextureIntensity = strength;
+                    }
+                    if (texCoord === TextureCoordinate.UV1) {
+                        m1.occlusionTextureCoord = TextureCoordinate.UV1;
+                    } else if (texCoord > TextureCoordinate.UV1) {
+                        Logger.warn("Occlusion texture uv coordinate must be UV0 or UV1.");
+                    }
+                }
+            }
+            if (OASIS_materials_remap) {
+                var _gltf_extensions;
+                gltf.extensions = (_gltf_extensions = gltf.extensions) != null ? _gltf_extensions : {};
+                var _gltf_extensions_OASIS_materials_remap;
+                gltf.extensions["OASIS_materials_remap"] = (_gltf_extensions_OASIS_materials_remap = gltf.extensions["OASIS_materials_remap"]) != null ? _gltf_extensions_OASIS_materials_remap : {};
+                gltf.extensions["OASIS_materials_remap"][i] = Parser.createEngineResource("OASIS_materials_remap", OASIS_materials_remap, context);
+            }
+            if (doubleSided) {
+                material.renderFace = RenderFace.Double;
+            } else {
+                material.renderFace = RenderFace.Front;
+            }
+            switch(alphaMode){
+                case MaterialAlphaMode.OPAQUE:
+                    material.isTransparent = false;
+                    break;
+                case MaterialAlphaMode.BLEND:
+                    material.isTransparent = true;
+                    break;
+                case MaterialAlphaMode.MASK:
+                    material.alphaCutoff = alphaCutoff != null ? alphaCutoff : 0.5;
+                    break;
+            }
+            materials[i] = material;
+        }
+        glTFResource.materials = materials;
+        materialsPromiseInfo.resolve(materials);
+        return materialsPromiseInfo.promise;
+    };
+    /** @internal */ MaterialParser._parseTextureTransform = function _parseTextureTransform(material, extensions, context) {
+        if (extensions === void 0) extensions = {};
+        var schema = extensions.KHR_texture_transform;
+        if (schema) {
+            Parser.parseEngineResource("KHR_texture_transform", schema, material, context);
+        }
+    };
+    return MaterialParser;
+}(Parser);
+
+var KHR_materials_clearcoat = /*#__PURE__*/ function(ExtensionParser) {
+    _inherits(KHR_materials_clearcoat, ExtensionParser);
+    function KHR_materials_clearcoat() {
+        return ExtensionParser.apply(this, arguments);
+    }
+    var _proto = KHR_materials_clearcoat.prototype;
+    _proto.parseEngineResource = function parseEngineResource(schema, material, context) {
+        var textures = context.glTFResource.textures;
+        var _schema_clearcoatFactor = schema.clearcoatFactor, clearcoatFactor = _schema_clearcoatFactor === void 0 ? 0 : _schema_clearcoatFactor, clearcoatTexture = schema.clearcoatTexture, _schema_clearcoatRoughnessFactor = schema.clearcoatRoughnessFactor, clearcoatRoughnessFactor = _schema_clearcoatRoughnessFactor === void 0 ? 0 : _schema_clearcoatRoughnessFactor, clearcoatRoughnessTexture = schema.clearcoatRoughnessTexture, clearcoatNormalTexture = schema.clearcoatNormalTexture;
+        material.clearCoat = clearcoatFactor;
+        material.clearCoatRoughness = clearcoatRoughnessFactor;
+        if (clearcoatTexture) {
+            material.clearCoatTexture = textures[clearcoatTexture.index];
+            MaterialParser._parseTextureTransform(material, clearcoatTexture.extensions, context);
+        }
+        if (clearcoatRoughnessTexture) {
+            material.clearCoatRoughnessTexture = textures[clearcoatRoughnessTexture.index];
+            MaterialParser._parseTextureTransform(material, clearcoatRoughnessTexture.extensions, context);
+        }
+        if (clearcoatNormalTexture) {
+            material.clearCoatNormalTexture = textures[clearcoatNormalTexture.index];
+            MaterialParser._parseTextureTransform(material, clearcoatNormalTexture.extensions, context);
+        }
+    };
+    return KHR_materials_clearcoat;
+}(ExtensionParser);
+KHR_materials_clearcoat = __decorate([
+    registerExtension("KHR_materials_clearcoat")
+], KHR_materials_clearcoat);
+
+var KHR_materials_pbrSpecularGlossiness = /*#__PURE__*/ function(ExtensionParser) {
+    _inherits(KHR_materials_pbrSpecularGlossiness, ExtensionParser);
+    function KHR_materials_pbrSpecularGlossiness() {
+        return ExtensionParser.apply(this, arguments);
+    }
+    var _proto = KHR_materials_pbrSpecularGlossiness.prototype;
+    _proto.createEngineResource = function createEngineResource(schema, context) {
+        var _context_glTFResource = context.glTFResource, engine = _context_glTFResource.engine, textures = _context_glTFResource.textures;
+        var material = new PBRSpecularMaterial(engine);
+        var diffuseFactor = schema.diffuseFactor, diffuseTexture = schema.diffuseTexture, specularFactor = schema.specularFactor, glossinessFactor = schema.glossinessFactor, specularGlossinessTexture = schema.specularGlossinessTexture;
+        if (diffuseFactor) {
+            material.baseColor = new Color(Color.linearToGammaSpace(diffuseFactor[0]), Color.linearToGammaSpace(diffuseFactor[1]), Color.linearToGammaSpace(diffuseFactor[2]), diffuseFactor[3]);
+        }
+        if (diffuseTexture) {
+            material.baseTexture = textures[diffuseTexture.index];
+            MaterialParser._parseTextureTransform(material, diffuseTexture.extensions, context);
+        }
+        if (specularFactor) {
+            material.specularColor = new Color(Color.linearToGammaSpace(specularFactor[0]), Color.linearToGammaSpace(specularFactor[1]), Color.linearToGammaSpace(specularFactor[2]));
+        }
+        if (glossinessFactor !== undefined) {
+            material.glossiness = glossinessFactor;
+        }
+        if (specularGlossinessTexture) {
+            material.specularGlossinessTexture = textures[specularGlossinessTexture.index];
+            MaterialParser._parseTextureTransform(material, specularGlossinessTexture.extensions, context);
+        }
+        return material;
+    };
+    return KHR_materials_pbrSpecularGlossiness;
+}(ExtensionParser);
+KHR_materials_pbrSpecularGlossiness = __decorate([
+    registerExtension("KHR_materials_pbrSpecularGlossiness")
+], KHR_materials_pbrSpecularGlossiness);
+
+var KHR_materials_unlit = /*#__PURE__*/ function(ExtensionParser) {
+    _inherits(KHR_materials_unlit, ExtensionParser);
+    function KHR_materials_unlit() {
+        return ExtensionParser.apply(this, arguments);
+    }
+    var _proto = KHR_materials_unlit.prototype;
+    _proto.createEngineResource = function createEngineResource(schema, context) {
+        var engine = context.glTFResource.engine;
+        var material = new UnlitMaterial(engine);
+        return material;
+    };
+    return KHR_materials_unlit;
+}(ExtensionParser);
+KHR_materials_unlit = __decorate([
+    registerExtension("KHR_materials_unlit")
+], KHR_materials_unlit);
+
+var KHR_materials_variants = /*#__PURE__*/ function(ExtensionParser) {
+    _inherits(KHR_materials_variants, ExtensionParser);
+    function KHR_materials_variants() {
+        return ExtensionParser.apply(this, arguments);
+    }
+    var _proto = KHR_materials_variants.prototype;
+    _proto.parseEngineResource = function parseEngineResource(schema, renderer, context) {
+        var _context_gltf = context.gltf, _context_gltf_extensions = _context_gltf.extensions, _context_gltf_extensions_KHR_materials_variants = _context_gltf_extensions.KHR_materials_variants, variantNames = _context_gltf_extensions_KHR_materials_variants.variants, glTFResource = context.glTFResource;
+        var mappings = schema.mappings;
+        for(var i = 0; i < mappings.length; i++){
+            var _mappings_i = mappings[i], material = _mappings_i.material, variants = _mappings_i.variants;
+            if (!glTFResource.variants) glTFResource.variants = [];
+            glTFResource.variants.push({
+                renderer: renderer,
+                material: glTFResource.materials[material],
+                variants: variants.map(function(index) {
+                    return variantNames[index].name;
+                })
+            });
+        }
+    };
+    return KHR_materials_variants;
+}(ExtensionParser);
+KHR_materials_variants = __decorate([
+    registerExtension("KHR_materials_variants")
+], KHR_materials_variants);
+
+var KHR_mesh_quantization = /*#__PURE__*/ function(ExtensionParser) {
+    _inherits(KHR_mesh_quantization, ExtensionParser);
+    function KHR_mesh_quantization() {
+        return ExtensionParser.apply(this, arguments);
+    }
+    return KHR_mesh_quantization;
+}(ExtensionParser);
+KHR_mesh_quantization = __decorate([
+    registerExtension("KHR_mesh_quantization")
+], KHR_mesh_quantization);
+
+var KHR_texture_transform = /*#__PURE__*/ function(ExtensionParser) {
+    _inherits(KHR_texture_transform, ExtensionParser);
+    function KHR_texture_transform() {
+        return ExtensionParser.apply(this, arguments);
+    }
+    var _proto = KHR_texture_transform.prototype;
+    _proto.parseEngineResource = function parseEngineResource(schema, material, context) {
+        var offset = schema.offset, rotation = schema.rotation, scale = schema.scale, texCoord = schema.texCoord;
+        if (offset) {
+            material.tilingOffset.z = offset[0];
+            material.tilingOffset.w = offset[1];
+        }
+        if (scale) {
+            material.tilingOffset.x = scale[0];
+            material.tilingOffset.y = scale[1];
+        }
+        if (rotation) {
+            Logger.warn("rotation in KHR_texture_transform is not supported now");
+        }
+        if (texCoord) {
+            Logger.warn("texCoord in KHR_texture_transform is not supported now");
+        }
+    };
+    return KHR_texture_transform;
+}(ExtensionParser);
+KHR_texture_transform = __decorate([
+    registerExtension("KHR_texture_transform")
+], KHR_texture_transform);
+
+var GalaceanMaterialsRemap = /*#__PURE__*/ function(ExtensionParser) {
+    _inherits(GalaceanMaterialsRemap, ExtensionParser);
+    function GalaceanMaterialsRemap() {
+        return ExtensionParser.apply(this, arguments);
+    }
+    var _proto = GalaceanMaterialsRemap.prototype;
+    _proto.createEngineResource = function createEngineResource(schema, context) {
+        var engine = context.glTFResource.engine;
+        // @ts-ignore
+        return engine.resourceManager.getResourceByRef(schema);
+    };
+    return GalaceanMaterialsRemap;
+}(ExtensionParser);
+GalaceanMaterialsRemap = __decorate([
+    registerExtension("OASIS_materials_remap")
+], GalaceanMaterialsRemap);
+
+function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+
+    if (it) return (it = it.call(o)).next.bind(it);
+    // Fallback for engines without symbol support
+    if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike && o && typeof o.length === "number") {
+        if (it) o = it;
+
+        var i = 0;
+
+        return function() {
+            if (i >= o.length) return { done: true };
+
+            return { done: false, value: o[i++] };
+        };
+    }
+
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+var AnimationParser = /*#__PURE__*/ function(Parser) {
+    _inherits(AnimationParser, Parser);
+    function AnimationParser() {
+        return Parser.apply(this, arguments);
+    }
+    var _proto = AnimationParser.prototype;
+    _proto.parse = function parse(context) {
+        var gltf = context.gltf; context.buffers; var glTFResource = context.glTFResource;
+        var entities = glTFResource.entities;
+        var animations = gltf.animations, accessors = gltf.accessors;
+        if (!animations) {
+            return;
+        }
+        var animationClipsPromiseInfo = context.animationClipsPromiseInfo;
+        var animationClipCount = animations.length;
+        var animationClips = new Array(animationClipCount);
+        var animationsIndices = new Array(animationClipCount);
+        for(var i = 0; i < animationClipCount; i++){
+            var gltfAnimation = animations[i];
+            var channels = gltfAnimation.channels, samplers = gltfAnimation.samplers, _gltfAnimation_name = gltfAnimation.name, name = _gltfAnimation_name === void 0 ? "AnimationClip" + i : _gltfAnimation_name;
+            var animationClip = new AnimationClip(name);
+            var sampleDataCollection = new Array();
+            // parse samplers
+            for(var j = 0, m = samplers.length; j < m; j++){
+                var gltfSampler = samplers[j];
+                var inputAccessor = accessors[gltfSampler.input];
+                var outputAccessor = accessors[gltfSampler.output];
+                var input = GLTFUtil.getAccessorBuffer(context, gltf, inputAccessor).data;
+                var output = GLTFUtil.getAccessorBuffer(context, gltf, outputAccessor).data;
+                if (outputAccessor.normalized) {
+                    var scale = GLTFUtil.getNormalizedComponentScale(outputAccessor.componentType);
+                    var scaled = new Float32Array(output.length);
+                    for(var k = 0, v = output.length; k < v; k++){
+                        scaled[k] = output[k] * scale;
+                    }
+                    output = scaled;
+                }
+                var outputStride = output.length / input.length;
+                var _gltfSampler_interpolation;
+                var interpolation = (_gltfSampler_interpolation = gltfSampler.interpolation) != null ? _gltfSampler_interpolation : AnimationSamplerInterpolation.Linear;
+                var samplerInterpolation = void 0;
+                switch(interpolation){
+                    case AnimationSamplerInterpolation.CubicSpine:
+                        samplerInterpolation = InterpolationType.CubicSpine;
+                        break;
+                    case AnimationSamplerInterpolation.Step:
+                        samplerInterpolation = InterpolationType.Step;
+                        break;
+                    case AnimationSamplerInterpolation.Linear:
+                        samplerInterpolation = InterpolationType.Linear;
+                        break;
+                }
+                input[input.length - 1];
+                sampleDataCollection.push({
+                    type: outputAccessor.type,
+                    interpolation: samplerInterpolation,
+                    input: input,
+                    output: output,
+                    outputSize: outputStride
+                });
+            }
+            for(var j1 = 0, m1 = channels.length; j1 < m1; j1++){
+                var gltfChannel = channels[j1];
+                var target = gltfChannel.target;
+                var channelTargetEntity = entities[target.node];
+                var relativePath = "";
+                var entity = channelTargetEntity;
+                while(entity.parent){
+                    relativePath = relativePath === "" ? "" + entity.name : entity.name + "/" + relativePath;
+                    entity = entity.parent;
+                }
+                var ComponentType = void 0;
+                var propertyName = void 0;
+                switch(target.path){
+                    case AnimationChannelTargetPath.TRANSLATION:
+                        ComponentType = Transform;
+                        propertyName = "position";
+                        break;
+                    case AnimationChannelTargetPath.ROTATION:
+                        ComponentType = Transform;
+                        propertyName = "rotationQuaternion";
+                        break;
+                    case AnimationChannelTargetPath.SCALE:
+                        ComponentType = Transform;
+                        propertyName = "scale";
+                        break;
+                    case AnimationChannelTargetPath.WEIGHTS:
+                        ComponentType = SkinnedMeshRenderer;
+                        propertyName = "blendShapeWeights";
+                        break;
+                }
+                var curve = this._addCurve(target.path, gltfChannel, sampleDataCollection);
+                animationClip.addCurveBinding(relativePath, ComponentType, propertyName, curve);
+            }
+            animationClips[i] = animationClip;
+            animationsIndices[i] = {
+                name: name,
+                index: i
+            };
+        }
+        glTFResource.animations = animationClips;
+        // @ts-ignore for editor
+        glTFResource._animationsIndices = animationsIndices;
+        animationClipsPromiseInfo.resolve(animationClips);
+        return animationClipsPromiseInfo.promise;
+    };
+    _proto._addCurve = function _addCurve(animationchannelTargetPath, gltfChannel, sampleDataCollection) {
+        var sampleData = sampleDataCollection[gltfChannel.sampler];
+        var input = sampleData.input, output = sampleData.output, outputSize = sampleData.outputSize;
+        switch(animationchannelTargetPath){
+            case AnimationChannelTargetPath.TRANSLATION:
+            case AnimationChannelTargetPath.SCALE:
                 {
                     var curve = new AnimationVector3Curve();
                     var interpolation = curve.interpolation = sampleData.interpolation;
@@ -1541,42 +1608,35 @@ var GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
                 }
         }
     };
-    return GLTFAnimationParser;
-}(GLTFParser);
+    return AnimationParser;
+}(Parser);
 
-var GLTFBufferParser = /*#__PURE__*/ function(GLTFParser) {
-    _inherits(GLTFBufferParser, GLTFParser);
-    function GLTFBufferParser() {
-        return GLTFParser.apply(this, arguments);
+var BufferParser = /*#__PURE__*/ function(Parser) {
+    _inherits(BufferParser, Parser);
+    function BufferParser() {
+        return Parser.apply(this, arguments);
     }
-    var _proto = GLTFBufferParser.prototype;
+    var _proto = BufferParser.prototype;
     _proto.parse = function parse(context) {
-        var glTFResource = context.glTFResource, contentRestorer = context.contentRestorer;
+        var glTFResource = context.glTFResource;
         var url = glTFResource.url;
-        var restoreBufferRequests = contentRestorer.bufferRequests;
-        var requestConfig = {
-            type: "arraybuffer"
-        };
-        var isGLB = this._isGLB(url);
-        contentRestorer.isGLB = isGLB;
-        if (isGLB) {
-            return request(url, requestConfig).then(function(glb) {
-                restoreBufferRequests.push(new BufferRequestInfo(url, requestConfig));
-                return GLTFUtil.parseGLB(context, glb);
-            }).then(function(param) {
-                var glTF = param.glTF, buffers = param.buffers;
-                context.glTF = glTF;
+        if (this._isGLB(url)) {
+            return request(url, {
+                type: "arraybuffer"
+            }).then(GLTFUtil.parseGLB).then(function(param) {
+                var gltf = param.gltf, buffers = param.buffers;
+                context.gltf = gltf;
                 context.buffers = buffers;
             });
         } else {
             return request(url, {
                 type: "json"
-            }).then(function(glTF) {
-                context.glTF = glTF;
-                return Promise.all(glTF.buffers.map(function(buffer) {
-                    var absoluteUrl = GLTFUtil.parseRelativeUrl(url, buffer.uri);
-                    restoreBufferRequests.push(new BufferRequestInfo(absoluteUrl, requestConfig));
-                    return request(absoluteUrl, requestConfig);
+            }).then(function(gltf) {
+                context.gltf = gltf;
+                return Promise.all(gltf.buffers.map(function(buffer) {
+                    return request(GLTFUtil.parseRelativeUrl(url, buffer.uri), {
+                        type: "arraybuffer"
+                    });
                 })).then(function(buffers) {
                     context.buffers = buffers;
                 });
@@ -1587,24 +1647,24 @@ var GLTFBufferParser = /*#__PURE__*/ function(GLTFParser) {
         var index = url.lastIndexOf(".");
         return url.substring(index + 1, index + 4) === "glb";
     };
-    return GLTFBufferParser;
-}(GLTFParser);
+    return BufferParser;
+}(Parser);
 
-var GLTFEntityParser = /*#__PURE__*/ function(GLTFParser) {
-    _inherits(GLTFEntityParser, GLTFParser);
-    function GLTFEntityParser() {
-        return GLTFParser.apply(this, arguments);
+var EntityParser = /*#__PURE__*/ function(Parser) {
+    _inherits(EntityParser, Parser);
+    function EntityParser() {
+        return Parser.apply(this, arguments);
     }
-    var _proto = GLTFEntityParser.prototype;
+    var _proto = EntityParser.prototype;
     _proto.parse = function parse(context) {
-        var glTFResource = context.glTFResource, nodes = context.glTF.nodes;
+        var glTFResource = context.glTFResource, nodes = context.gltf.nodes;
         var engine = glTFResource.engine;
         if (!nodes) return;
         var entities = [];
         for(var i = 0; i < nodes.length; i++){
             var gltfNode = nodes[i];
             var matrix = gltfNode.matrix, translation = gltfNode.translation, rotation = gltfNode.rotation, scale = gltfNode.scale;
-            var entity = new Entity(engine, gltfNode.name || "" + GLTFEntityParser._defaultName + i);
+            var entity = new Entity(engine, gltfNode.name || "" + EntityParser._defaultName + i);
             var transform = entity.transform;
             if (matrix) {
                 var localMatrix = transform.localMatrix;
@@ -1628,7 +1688,7 @@ var GLTFEntityParser = /*#__PURE__*/ function(GLTFParser) {
         this._createSceneRoots(context, glTFResource);
     };
     _proto._buildEntityTree = function _buildEntityTree(context, glTFResource) {
-        var nodes = context.glTF.nodes;
+        var nodes = context.gltf.nodes;
         var entities = glTFResource.entities;
         for(var i = 0; i < nodes.length; i++){
             var children = nodes[i].children;
@@ -1642,7 +1702,7 @@ var GLTFEntityParser = /*#__PURE__*/ function(GLTFParser) {
         }
     };
     _proto._createSceneRoots = function _createSceneRoots(context, glTFResource) {
-        var _context_glTF = context.glTF, tmp = _context_glTF.scene, sceneID = tmp === void 0 ? 0 : tmp, scenes = _context_glTF.scenes;
+        var _context_gltf = context.gltf, tmp = _context_gltf.scene, sceneID = tmp === void 0 ? 0 : tmp, scenes = _context_gltf.scenes;
         var engine = glTFResource.engine, entities = glTFResource.entities;
         if (!scenes) return;
         var sceneRoots = [];
@@ -1662,193 +1722,79 @@ var GLTFEntityParser = /*#__PURE__*/ function(GLTFParser) {
         glTFResource.sceneRoots = sceneRoots;
         glTFResource.defaultSceneRoot = sceneRoots[sceneID];
     };
-    return GLTFEntityParser;
-}(GLTFParser);
-/** @internal */ GLTFEntityParser._defaultName = "_GLTF_ENTITY_";
+    return EntityParser;
+}(Parser);
+(function() {
+    /** @internal */ EntityParser._defaultName = "_GLTF_ENTITY_";
+})();
 
-var GLTFMaterialParser = /*#__PURE__*/ function(GLTFParser1) {
-    _inherits(GLTFMaterialParser, GLTFParser1);
-    function GLTFMaterialParser() {
-        return GLTFParser1.apply(this, arguments);
+var MeshParser = /*#__PURE__*/ function(Parser1) {
+    _inherits(MeshParser, Parser1);
+    function MeshParser() {
+        return Parser1.apply(this, arguments);
     }
-    var _proto = GLTFMaterialParser.prototype;
+    var _proto = MeshParser.prototype;
     _proto.parse = function parse(context) {
-        var glTF = context.glTF, glTFResource = context.glTFResource, materialsPromiseInfo = context.materialsPromiseInfo;
-        if (!glTF.materials) return;
+        var _loop = function(i) {
+            var _loop = function(j) {
+                var gltfPrimitive = gltfMesh.primitives[j];
+                var _gltfPrimitive_extensions = gltfPrimitive.extensions, extensions = _gltfPrimitive_extensions === void 0 ? {} : _gltfPrimitive_extensions;
+                var KHR_draco_mesh_compression = extensions.KHR_draco_mesh_compression;
+                primitivePromises[j] = new Promise(function(resolve) {
+                    var mesh = new ModelMesh(engine, gltfMesh.name || j + "");
+                    if (KHR_draco_mesh_compression) {
+                        Parser.createEngineResource("KHR_draco_mesh_compression", KHR_draco_mesh_compression, context, gltfPrimitive).then(function(decodedGeometry) {
+                            return _this._parseMeshFromGLTFPrimitiveDraco(mesh, gltfMesh, gltfPrimitive, gltf, function(attributeSemantic) {
+                                for(var j = 0; j < decodedGeometry.attributes.length; j++){
+                                    if (decodedGeometry.attributes[j].name === attributeSemantic) {
+                                        return decodedGeometry.attributes[j].array;
+                                    }
+                                }
+                                return null;
+                            }, function(attributeSemantic, shapeIndex) {
+                                throw "BlendShape animation is not supported when using draco.";
+                            }, function() {
+                                return decodedGeometry.index.array;
+                            }, context.keepMeshData);
+                        }).then(resolve);
+                    } else {
+                        _this._parseMeshFromGLTFPrimitive(context, mesh, gltfMesh, gltfPrimitive, gltf, function(attributeSemantic) {
+                            return null;
+                        }, function(attributeName, shapeIndex) {
+                            var shapeAccessorIdx = gltfPrimitive.targets[shapeIndex];
+                            var attributeAccessorIdx = shapeAccessorIdx[attributeName];
+                            if (attributeAccessorIdx) {
+                                var accessor = gltf.accessors[attributeAccessorIdx];
+                                return GLTFUtil.getAccessorData(gltf, accessor, buffers);
+                            } else {
+                                return null;
+                            }
+                        }, function() {
+                            var indexAccessor = gltf.accessors[gltfPrimitive.indices];
+                            return GLTFUtil.getAccessorData(gltf, indexAccessor, buffers);
+                        }, context.keepMeshData).then(resolve);
+                    }
+                });
+            };
+            var gltfMesh = gltf.meshes[i];
+            var primitivePromises = [];
+            for(var j = 0; j < gltfMesh.primitives.length; j++)_loop(j);
+            meshPromises[i] = Promise.all(primitivePromises);
+        };
+        var _this = this;
+        var gltf = context.gltf, buffers = context.buffers, glTFResource = context.glTFResource;
         var engine = glTFResource.engine;
-        var materialPromises = [];
-        for(var i = 0; i < glTF.materials.length; i++){
-            var materialInfo = glTF.materials[i];
-            var material = GLTFParser.executeExtensionsCreateAndParse(materialInfo.extensions, context, materialInfo);
-            if (!material) {
-                material = new PBRMaterial(engine);
-                material.name = materialInfo.name;
-                GLTFMaterialParser._parseStandardProperty(context, material, materialInfo);
-            }
-            materialPromises.push(material);
-        }
-        return AssetPromise.all(materialPromises).then(function(materials) {
-            glTFResource.materials = materials;
-            for(var i = 0; i < glTF.materials.length; i++){
-                var materialInfo = glTF.materials[i];
-                GLTFParser.executeExtensionsAdditiveAndParse(materialInfo.extensions, context, materials[i], materialInfo);
-            }
-            materialsPromiseInfo.resolve(materials);
-            return materialsPromiseInfo.promise;
-        });
-    };
-    /**
-   * @internal
-   */ GLTFMaterialParser._checkOtherTextureTransform = function _checkOtherTextureTransform(texture, textureName) {
-        var _texture_extensions;
-        if ((_texture_extensions = texture.extensions) == null ? void 0 : _texture_extensions.KHR_texture_transform) {
-            Logger.warn("" + textureName + " texture always use the KHR_texture_transform of the base texture.");
-        }
-    };
-    /**
-   * @internal
-   */ GLTFMaterialParser._parseStandardProperty = function _parseStandardProperty(context, material, materialInfo) {
-        var textures = context.glTFResource.textures;
-        var pbrMetallicRoughness = materialInfo.pbrMetallicRoughness, normalTexture = materialInfo.normalTexture, occlusionTexture = materialInfo.occlusionTexture, emissiveTexture = materialInfo.emissiveTexture, emissiveFactor = materialInfo.emissiveFactor, alphaMode = materialInfo.alphaMode, alphaCutoff = materialInfo.alphaCutoff, doubleSided = materialInfo.doubleSided;
-        if (pbrMetallicRoughness) {
-            var baseColorFactor = pbrMetallicRoughness.baseColorFactor, baseColorTexture = pbrMetallicRoughness.baseColorTexture, metallicFactor = pbrMetallicRoughness.metallicFactor, roughnessFactor = pbrMetallicRoughness.roughnessFactor, metallicRoughnessTexture = pbrMetallicRoughness.metallicRoughnessTexture;
-            if (baseColorFactor) {
-                material.baseColor = new Color(Color.linearToGammaSpace(baseColorFactor[0]), Color.linearToGammaSpace(baseColorFactor[1]), Color.linearToGammaSpace(baseColorFactor[2]), baseColorFactor[3]);
-            }
-            if (baseColorTexture) {
-                material.baseTexture = textures[baseColorTexture.index];
-                GLTFParser.executeExtensionsAdditiveAndParse(baseColorTexture.extensions, context, material, baseColorTexture);
-            }
-            if (material.constructor === PBRMaterial) {
-                material.metallic = metallicFactor != null ? metallicFactor : 1;
-                material.roughness = roughnessFactor != null ? roughnessFactor : 1;
-                if (metallicRoughnessTexture) {
-                    material.roughnessMetallicTexture = textures[metallicRoughnessTexture.index];
-                    GLTFMaterialParser._checkOtherTextureTransform(metallicRoughnessTexture, "Roughness metallic");
-                }
-            }
-        }
-        if (material.constructor === PBRMaterial || material.constructor === PBRSpecularMaterial) {
-            if (emissiveTexture) {
-                material.emissiveTexture = textures[emissiveTexture.index];
-                GLTFMaterialParser._checkOtherTextureTransform(emissiveTexture, "Emissive");
-            }
-            if (emissiveFactor) {
-                material.emissiveColor = new Color(Color.linearToGammaSpace(emissiveFactor[0]), Color.linearToGammaSpace(emissiveFactor[1]), Color.linearToGammaSpace(emissiveFactor[2]));
-            }
-            if (normalTexture) {
-                var index = normalTexture.index, scale = normalTexture.scale;
-                material.normalTexture = textures[index];
-                GLTFMaterialParser._checkOtherTextureTransform(normalTexture, "Normal");
-                if (scale !== undefined) {
-                    material.normalTextureIntensity = scale;
-                }
-            }
-            if (occlusionTexture) {
-                var index1 = occlusionTexture.index, strength = occlusionTexture.strength, texCoord = occlusionTexture.texCoord;
-                material.occlusionTexture = textures[index1];
-                GLTFMaterialParser._checkOtherTextureTransform(occlusionTexture, "Occlusion");
-                if (strength !== undefined) {
-                    material.occlusionTextureIntensity = strength;
-                }
-                if (texCoord === TextureCoordinate.UV1) {
-                    material.occlusionTextureCoord = TextureCoordinate.UV1;
-                } else if (texCoord > TextureCoordinate.UV1) {
-                    Logger.warn("Occlusion texture uv coordinate must be UV0 or UV1.");
-                }
-            }
-        }
-        if (doubleSided) {
-            material.renderFace = RenderFace.Double;
-        } else {
-            material.renderFace = RenderFace.Front;
-        }
-        switch(alphaMode){
-            case MaterialAlphaMode.OPAQUE:
-                material.isTransparent = false;
-                break;
-            case MaterialAlphaMode.BLEND:
-                material.isTransparent = true;
-                break;
-            case MaterialAlphaMode.MASK:
-                material.alphaCutoff = alphaCutoff != null ? alphaCutoff : 0.5;
-                break;
-        }
-    };
-    return GLTFMaterialParser;
-}(GLTFParser);
-
-function _instanceof(left, right) {
-  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-    return !!right[Symbol.hasInstance](left);
-  } else {
-    return left instanceof right;
-  }
-}
-
-var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
-    _inherits(GLTFMeshParser, GLTFParser1);
-    function GLTFMeshParser() {
-        return GLTFParser1.apply(this, arguments);
-    }
-    var _proto = GLTFMeshParser.prototype;
-    _proto.parse = function parse(context) {
-        var _loop = function(i) {
-            var _loop = function(j) {
-                var gltfPrimitive = gltfMesh.primitives[j];
-                primitivePromises[j] = new Promise(function(resolve) {
-                    var mesh = GLTFParser.executeExtensionsCreateAndParse(gltfPrimitive.extensions, context, gltfPrimitive, gltfMesh);
-                    if (mesh) {
-                        if (_instanceof(mesh, ModelMesh)) {
-                            resolve(mesh);
-                        } else {
-                            mesh.then(function(mesh) {
-                                return resolve(mesh);
-                            });
-                        }
-                    } else {
-                        var mesh1 = new ModelMesh(engine, gltfMesh.name || j + "");
-                        var meshRestoreInfo = new ModelMeshRestoreInfo();
-                        meshRestoreInfo.mesh = mesh1;
-                        context.contentRestorer.meshes.push(meshRestoreInfo);
-                        GLTFMeshParser._parseMeshFromGLTFPrimitive(context, mesh1, meshRestoreInfo, gltfMesh, gltfPrimitive, glTF, function(attributeSemantic) {
-                            return null;
-                        }, function(attributeName, shapeIndex) {
-                            var shapeAccessorIdx = gltfPrimitive.targets[shapeIndex];
-                            var attributeAccessorIdx = shapeAccessorIdx[attributeName];
-                            if (attributeAccessorIdx) {
-                                var accessor = glTF.accessors[attributeAccessorIdx];
-                                return GLTFUtil.getAccessorBuffer(context, context.glTF.bufferViews, accessor);
-                            } else {
-                                return null;
-                            }
-                        }, function() {
-                            var indexAccessor = glTF.accessors[gltfPrimitive.indices];
-                            return GLTFUtil.getAccessorData(glTF, indexAccessor, buffers);
-                        }, context.keepMeshData).then(resolve);
-                    }
-                });
-            };
-            var gltfMesh = glTF.meshes[i];
-            var primitivePromises = [];
-            for(var j = 0; j < gltfMesh.primitives.length; j++)_loop(j);
-            meshPromises[i] = Promise.all(primitivePromises);
-        };
-        var glTF = context.glTF, buffers = context.buffers, glTFResource = context.glTFResource;
-        var engine = glTFResource.engine;
-        if (!glTF.meshes) return;
+        if (!gltf.meshes) return;
         var meshesPromiseInfo = context.meshesPromiseInfo;
         var meshPromises = [];
-        for(var i = 0; i < glTF.meshes.length; i++)_loop(i);
+        for(var i = 0; i < gltf.meshes.length; i++)_loop(i);
         AssetPromise.all(meshPromises).then(function(meshes) {
             glTFResource.meshes = meshes;
             meshesPromiseInfo.resolve(meshes);
         }).catch(meshesPromiseInfo.reject);
         return meshesPromiseInfo.promise;
     };
-    /**
-   * @internal
-   */ GLTFMeshParser._parseMeshFromGLTFPrimitive = function _parseMeshFromGLTFPrimitive(context, mesh, meshRestoreInfo, gltfMesh, gltfPrimitive, gltf, getVertexBufferData, getBlendShapeData, getIndexBufferData, keepMeshData) {
+    _proto._parseMeshFromGLTFPrimitive = function _parseMeshFromGLTFPrimitive(context, mesh, gltfMesh, gltfPrimitive, gltf, getVertexBufferData, getBlendShapeData, getIndexBufferData, keepMeshData) {
         var accessors = gltf.accessors;
         context.buffers;
         var attributes = gltfPrimitive.attributes, targets = gltfPrimitive.targets, indices = gltfPrimitive.indices, mode = gltfPrimitive.mode;
@@ -1856,16 +1802,18 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
         var vertexElements = new Array();
         var vertexCount;
         var bufferBindIndex = 0;
+        var positions;
+        keepMeshData && (positions = new Array(vertexCount));
         for(var attribute in attributes){
             var accessor = accessors[attributes[attribute]];
-            var accessorBuffer = GLTFUtil.getAccessorBuffer(context, gltf.bufferViews, accessor);
-            var dataElementSize = GLTFUtil.getAccessorTypeSize(accessor.type);
+            var accessorBuffer = GLTFUtil.getAccessorBuffer(context, gltf, accessor);
+            var dataElmentSize = GLTFUtil.getAccessorTypeSize(accessor.type);
             var attributeCount = accessor.count;
             var vertices = accessorBuffer.data;
             var vertexElement = void 0;
             var meshId = mesh.instanceId;
             var vertexBindingInfos = accessorBuffer.vertexBindingInfos;
-            var elementFormat = GLTFUtil.getElementFormat(accessor.componentType, dataElementSize, accessor.normalized);
+            var elementFormat = GLTFUtil.getElementFormat(accessor.componentType, dataElmentSize, accessor.normalized);
             if (accessorBuffer.interleaved) {
                 var byteOffset = accessor.byteOffset || 0;
                 var stride = accessorBuffer.stride;
@@ -1877,7 +1825,6 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
                         vertexBuffer = new Buffer(engine, BufferBindFlag.VertexBuffer, vertices.byteLength, BufferUsage.Static);
                         vertexBuffer.setData(vertices);
                         accessorBuffer.vertexBuffer = vertexBuffer;
-                        meshRestoreInfo.vertexBuffers.push(new BufferRestoreInfo(vertexBuffer, accessorBuffer.restoreInfo));
                     }
                     mesh.setVertexBufferBinding(vertexBuffer, stride, bufferBindIndex);
                     vertexBindingInfos[meshId] = bufferBindIndex++;
@@ -1888,7 +1835,6 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
                 vertexElement = new VertexElement(attribute, 0, elementFormat, bufferBindIndex);
                 var vertexBuffer1 = new Buffer(engine, BufferBindFlag.VertexBuffer, vertices.byteLength, BufferUsage.Static);
                 vertexBuffer1.setData(vertices);
-                meshRestoreInfo.vertexBuffers.push(new BufferRestoreInfo(vertexBuffer1, accessorBuffer.restoreInfo));
                 mesh.setVertexBufferBinding(vertexBuffer1, accessorBuffer.stride, bufferBindIndex);
                 vertexBindingInfos[meshId] = bufferBindIndex++;
             }
@@ -1899,22 +1845,30 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
                 if (accessor.min && accessor.max) {
                     min.copyFromArray(accessor.min);
                     max.copyFromArray(accessor.max);
+                    if (keepMeshData) {
+                        var stride1 = vertices.length / attributeCount;
+                        for(var j = 0; j < attributeCount; j++){
+                            var offset = j * stride1;
+                            positions[j] = new Vector3(vertices[offset], vertices[offset + 1], vertices[offset + 2]);
+                        }
+                    }
                 } else {
-                    var position = GLTFMeshParser._tempVector3;
+                    var position = MeshParser._tempVector3;
                     min.set(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
                     max.set(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
-                    var stride1 = vertices.length / attributeCount;
-                    for(var j = 0; j < attributeCount; j++){
-                        var offset = j * stride1;
-                        position.copyFromArray(vertices, offset);
+                    var stride2 = vertices.length / attributeCount;
+                    for(var j1 = 0; j1 < attributeCount; j1++){
+                        var offset1 = j1 * stride2;
+                        position.copyFromArray(vertices, offset1);
                         Vector3.min(min, position, min);
                         Vector3.max(max, position, max);
+                        keepMeshData && (positions[j1] = position.clone());
                     }
                 }
                 if (accessor.normalized) {
-                    var scaleFactor = GLTFUtil.getNormalizedComponentScale(accessor.componentType);
-                    min.scale(scaleFactor);
-                    max.scale(scaleFactor);
+                    var sacleFactor = GLTFUtil.getNormalizedComponentScale(accessor.componentType);
+                    min.scale(sacleFactor);
+                    max.scale(sacleFactor);
                 }
             }
         }
@@ -1922,68 +1876,179 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
         // Indices
         if (indices !== undefined) {
             var indexAccessor = gltf.accessors[indices];
-            var accessorBuffer1 = GLTFUtil.getAccessorBuffer(context, gltf.bufferViews, indexAccessor);
-            mesh.setIndices(accessorBuffer1.data);
+            var indexData = getIndexBufferData();
+            mesh.setIndices(indexData);
             mesh.addSubMesh(0, indexAccessor.count, mode);
-            meshRestoreInfo.indexBuffer = accessorBuffer1.restoreInfo;
         } else {
             mesh.addSubMesh(0, vertexCount, mode);
         }
         // BlendShapes
-        targets && GLTFMeshParser._createBlendShape(mesh, meshRestoreInfo, gltfMesh, targets, getBlendShapeData);
+        targets && this._createBlendShape(mesh, gltfMesh, targets, getBlendShapeData);
         mesh.uploadData(!keepMeshData);
+        //@ts-ignore
+        mesh._positions = positions;
         return Promise.resolve(mesh);
     };
-    /**
-   * @internal
-   */ GLTFMeshParser._createBlendShape = function _createBlendShape(mesh, meshRestoreInfo, glTFMesh, glTFTargets, getBlendShapeData) {
+    _proto._createBlendShape = function _createBlendShape(mesh, glTFMesh, glTFTargets, getBlendShapeData) {
         var blendShapeNames = glTFMesh.extras ? glTFMesh.extras.targetNames : null;
         for(var i = 0, n = glTFTargets.length; i < n; i++){
             var name = blendShapeNames ? blendShapeNames[i] : "blendShape" + i;
-            var deltaPosBufferInfo = getBlendShapeData("POSITION", i);
-            var deltaNorBufferInfo = getBlendShapeData("NORMAL", i);
-            var deltaTanBufferInfo = getBlendShapeData("TANGENT", i);
-            var deltaPositions = deltaPosBufferInfo.data ? GLTFUtil.floatBufferToVector3Array(deltaPosBufferInfo.data) : null;
-            var deltaNormals = (deltaNorBufferInfo == null ? void 0 : deltaNorBufferInfo.data) ? GLTFUtil.floatBufferToVector3Array(deltaNorBufferInfo == null ? void 0 : deltaNorBufferInfo.data) : null;
-            var deltaTangents = (deltaTanBufferInfo == null ? void 0 : deltaTanBufferInfo.data) ? GLTFUtil.floatBufferToVector3Array(deltaTanBufferInfo == null ? void 0 : deltaTanBufferInfo.data) : null;
+            var deltaPosBuffer = getBlendShapeData("POSITION", i);
+            var deltaNorBuffer = getBlendShapeData("NORMAL", i);
+            var deltaTanBuffer = getBlendShapeData("TANGENT", i);
+            var deltaPositions = deltaPosBuffer ? GLTFUtil.floatBufferToVector3Array(deltaPosBuffer) : null;
+            var deltaNormals = deltaNorBuffer ? GLTFUtil.floatBufferToVector3Array(deltaNorBuffer) : null;
+            var deltaTangents = deltaTanBuffer ? GLTFUtil.floatBufferToVector3Array(deltaTanBuffer) : null;
             var blendShape = new BlendShape(name);
             blendShape.addFrame(1.0, deltaPositions, deltaNormals, deltaTangents);
             mesh.addBlendShape(blendShape);
-            meshRestoreInfo.blendShapes.push(new BlendShapeRestoreInfo(blendShape, deltaPosBufferInfo.restoreInfo, deltaNorBufferInfo == null ? void 0 : deltaNorBufferInfo.restoreInfo, deltaTanBufferInfo == null ? void 0 : deltaTanBufferInfo.restoreInfo));
         }
     };
-    return GLTFMeshParser;
-}(GLTFParser);
-GLTFMeshParser._tempVector3 = new Vector3();
+    /**
+   * @deprecated
+   */ _proto._parseMeshFromGLTFPrimitiveDraco = function _parseMeshFromGLTFPrimitiveDraco(mesh, gltfMesh, gltfPrimitive, gltf, getVertexBufferData, getBlendShapeData, getIndexBufferData, keepMeshData) {
+        var attributes = gltfPrimitive.attributes, targets = gltfPrimitive.targets, indices = gltfPrimitive.indices, mode = gltfPrimitive.mode;
+        var vertexCount;
+        var accessors = gltf.accessors;
+        var accessor = accessors[attributes["POSITION"]];
+        var positionBuffer = getVertexBufferData("POSITION");
+        var positions = GLTFUtil.floatBufferToVector3Array(positionBuffer);
+        mesh.setPositions(positions);
+        var bounds = mesh.bounds;
+        vertexCount = accessor.count;
+        if (accessor.min && accessor.max) {
+            bounds.min.copyFromArray(accessor.min);
+            bounds.max.copyFromArray(accessor.max);
+        } else {
+            var position = MeshParser._tempVector3;
+            var min = bounds.min, max = bounds.max;
+            min.set(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
+            max.set(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
+            var stride = positionBuffer.length / vertexCount;
+            for(var j = 0; j < vertexCount; j++){
+                var offset = j * stride;
+                position.copyFromArray(positionBuffer, offset);
+                Vector3.min(min, position, min);
+                Vector3.max(max, position, max);
+            }
+        }
+        for(var attributeSemantic in attributes){
+            if (attributeSemantic === "POSITION") {
+                continue;
+            }
+            var bufferData = getVertexBufferData(attributeSemantic);
+            switch(attributeSemantic){
+                case "NORMAL":
+                    var normals = GLTFUtil.floatBufferToVector3Array(bufferData);
+                    mesh.setNormals(normals);
+                    break;
+                case "TEXCOORD_0":
+                    var texturecoords = GLTFUtil.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords, 0);
+                    break;
+                case "TEXCOORD_1":
+                    var texturecoords1 = GLTFUtil.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords1, 1);
+                    break;
+                case "TEXCOORD_2":
+                    var texturecoords2 = GLTFUtil.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords2, 2);
+                    break;
+                case "TEXCOORD_3":
+                    var texturecoords3 = GLTFUtil.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords3, 3);
+                    break;
+                case "TEXCOORD_4":
+                    var texturecoords4 = GLTFUtil.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords4, 4);
+                    break;
+                case "TEXCOORD_5":
+                    var texturecoords5 = GLTFUtil.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords5, 5);
+                    break;
+                case "TEXCOORD_6":
+                    var texturecoords6 = GLTFUtil.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords6, 6);
+                    break;
+                case "TEXCOORD_7":
+                    var texturecoords7 = GLTFUtil.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords7, 7);
+                    break;
+                case "COLOR_0":
+                    var colors = GLTFUtil.floatBufferToColorArray(bufferData, accessors[attributes["COLOR_0"]].type === AccessorType.VEC3);
+                    mesh.setColors(colors);
+                    break;
+                case "TANGENT":
+                    var tangents = GLTFUtil.floatBufferToVector4Array(bufferData);
+                    mesh.setTangents(tangents);
+                    break;
+                case "JOINTS_0":
+                    var joints = GLTFUtil.floatBufferToVector4Array(bufferData);
+                    mesh.setBoneIndices(joints);
+                    break;
+                case "WEIGHTS_0":
+                    var weights = GLTFUtil.floatBufferToVector4Array(bufferData);
+                    mesh.setBoneWeights(weights);
+                    break;
+            }
+        }
+        // Indices
+        if (indices !== undefined) {
+            var indexAccessor = gltf.accessors[indices];
+            var indexData = getIndexBufferData();
+            mesh.setIndices(indexData);
+            mesh.addSubMesh(0, indexAccessor.count, mode);
+        } else {
+            mesh.addSubMesh(0, vertexCount, mode);
+        }
+        // BlendShapes
+        targets && this._createBlendShape(mesh, gltfMesh, targets, getBlendShapeData);
+        mesh.uploadData(!keepMeshData);
+        return Promise.resolve(mesh);
+    };
+    return MeshParser;
+}(Parser);
+(function() {
+    MeshParser._tempVector3 = new Vector3();
+})();
 
-var GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
-    _inherits(GLTFSceneParser, GLTFParser1);
-    function GLTFSceneParser() {
-        return GLTFParser1.apply(this, arguments);
+var SceneParser$1 = /*#__PURE__*/ function(Parser1) {
+    _inherits(SceneParser, Parser1);
+    function SceneParser() {
+        return Parser1.apply(this, arguments);
     }
-    var _proto = GLTFSceneParser.prototype;
+    var _proto = SceneParser.prototype;
     _proto.parse = function parse(context) {
-        var glTFResource = context.glTFResource, glTF = context.glTF;
+        var glTFResource = context.glTFResource, gltf = context.gltf;
         var entities = glTFResource.entities;
-        var nodes = glTF.nodes, cameras = glTF.cameras;
+        var nodes = gltf.nodes, gltfCameras = gltf.cameras;
         if (!nodes) return;
         var defaultSceneRootPromiseInfo = context.defaultSceneRootPromiseInfo;
+        var promises = [];
         for(var i = 0; i < nodes.length; i++){
-            var glTFNode = nodes[i];
-            var cameraID = glTFNode.camera, meshID = glTFNode.mesh, extensions = glTFNode.extensions;
+            var gltfNode = nodes[i];
+            var cameraID = gltfNode.camera, meshID = gltfNode.mesh, _gltfNode_extensions = gltfNode.extensions, extensions = _gltfNode_extensions === void 0 ? {} : _gltfNode_extensions;
+            var KHR_lights_punctual = extensions.KHR_lights_punctual;
             var entity = entities[i];
             if (cameraID !== undefined) {
-                this._createCamera(glTFResource, cameras[cameraID], entity);
+                this._createCamera(glTFResource, gltfCameras[cameraID], entity);
             }
             if (meshID !== undefined) {
-                this._createRenderer(context, glTFNode, entity);
+                promises.push(this._createRenderer(context, gltfNode, entity));
+            }
+            if (KHR_lights_punctual) {
+                var lightIndex = KHR_lights_punctual.light;
+                var lights = gltf.extensions.KHR_lights_punctual.lights;
+                Parser.parseEngineResource("KHR_lights_punctual", lights[lightIndex], entity, context);
             }
-            GLTFParser.executeExtensionsAdditiveAndParse(extensions, context, entity, glTFNode);
         }
         if (glTFResource.defaultSceneRoot) {
             this._createAnimator(context);
         }
-        defaultSceneRootPromiseInfo.resolve(glTFResource.defaultSceneRoot);
+        gltf.extensions && delete gltf.extensions["OASIS_materials_remap"];
+        AssetPromise.all(promises).then(function() {
+            return defaultSceneRootPromiseInfo.resolve(glTFResource.defaultSceneRoot);
+        }).catch(defaultSceneRootPromiseInfo.reject);
         return defaultSceneRootPromiseInfo.promise;
     };
     _proto._createCamera = function _createCamera(context, cameraSchema, entity) {
@@ -2019,16 +2084,8 @@ var GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
         // @todo: use engine camera by default
         camera.enabled = false;
     };
-    _proto._createRenderer = function _createRenderer(context, glTFNode, entity) {
-        var glTFResource = context.glTFResource, glTF = context.glTF;
-        var glTFMeshes = glTF.meshes;
-        var engine = glTFResource.engine, meshes = glTFResource.meshes, materials = glTFResource.materials, skins = glTFResource.skins;
-        var meshID = glTFNode.mesh, skinID = glTFNode.skin;
-        var glTFMesh = glTFMeshes[meshID];
-        var glTFMeshPrimitives = glTFMesh.primitives;
-        var blendShapeWeights = glTFNode.weights || glTFMesh.weights;
-        for(var i = 0; i < glTFMeshPrimitives.length; i++){
-            var gltfPrimitive = glTFMeshPrimitives[i];
+    _proto._createRenderer = function _createRenderer(context, gltfNode, entity) {
+        var _loop = function(i) {
             var mesh = meshes[meshID][i];
             var renderer = void 0;
             if (skinID !== undefined || blendShapeWeights) {
@@ -2046,11 +2103,32 @@ var GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
                 renderer = entity.addComponent(MeshRenderer);
                 renderer.mesh = mesh;
             }
-            var materialIndex = gltfPrimitive.material;
-            var material = (materials == null ? void 0 : materials[materialIndex]) || GLTFSceneParser._getDefaultMaterial(engine);
-            renderer.setMaterial(material);
-            GLTFParser.executeExtensionsAdditiveAndParse(gltfPrimitive.extensions, context, renderer, gltfPrimitive);
-        }
+            var materialIndex = gltfMeshPrimitives[i].material;
+            var remapMaterials = gltf.extensions && gltf.extensions["OASIS_materials_remap"];
+            if (remapMaterials && remapMaterials[materialIndex]) {
+                promises.push(remapMaterials[materialIndex].then(function(mtl) {
+                    renderer.setMaterial(mtl);
+                }));
+            } else {
+                var material = (materials == null ? void 0 : materials[materialIndex]) || SceneParser._getDefaultMaterial(engine);
+                renderer.setMaterial(material);
+            }
+            var _gltfMeshPrimitives_i = gltfMeshPrimitives[i], _gltfMeshPrimitives_i_extensions = _gltfMeshPrimitives_i.extensions, extensions = _gltfMeshPrimitives_i_extensions === void 0 ? {} : _gltfMeshPrimitives_i_extensions;
+            var KHR_materials_variants = extensions.KHR_materials_variants;
+            if (KHR_materials_variants) {
+                Parser.parseEngineResource("KHR_materials_variants", KHR_materials_variants, renderer, context);
+            }
+        };
+        var glTFResource = context.glTFResource, gltf = context.gltf;
+        var gltfMeshes = gltf.meshes;
+        var engine = glTFResource.engine, meshes = glTFResource.meshes, materials = glTFResource.materials, skins = glTFResource.skins;
+        var meshID = gltfNode.mesh, skinID = gltfNode.skin;
+        var glTFMesh = gltfMeshes[meshID];
+        var gltfMeshPrimitives = glTFMesh.primitives;
+        var blendShapeWeights = gltfNode.weights || glTFMesh.weights;
+        var promises = [];
+        for(var i = 0; i < gltfMeshPrimitives.length; i++)_loop(i);
+        return Promise.all(promises);
     };
     _proto._createAnimator = function _createAnimator(context) {
         if (!context.hasSkinned && !context.glTFResource.animations) {
@@ -2077,25 +2155,25 @@ var GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
             }
         }
     };
-    GLTFSceneParser._getDefaultMaterial = function _getDefaultMaterial(engine) {
-        if (!GLTFSceneParser._defaultMaterial) {
-            GLTFSceneParser._defaultMaterial = new BlinnPhongMaterial(engine);
+    SceneParser._getDefaultMaterial = function _getDefaultMaterial(engine) {
+        if (!SceneParser._defaultMaterial) {
+            SceneParser._defaultMaterial = new BlinnPhongMaterial(engine);
         }
-        return GLTFSceneParser._defaultMaterial;
+        return SceneParser._defaultMaterial;
     };
-    return GLTFSceneParser;
-}(GLTFParser);
+    return SceneParser;
+}(Parser);
 
-var GLTFSkinParser = /*#__PURE__*/ function(GLTFParser) {
-    _inherits(GLTFSkinParser, GLTFParser);
-    function GLTFSkinParser() {
-        return GLTFParser.apply(this, arguments);
+var SkinParser = /*#__PURE__*/ function(Parser) {
+    _inherits(SkinParser, Parser);
+    function SkinParser() {
+        return Parser.apply(this, arguments);
     }
-    var _proto = GLTFSkinParser.prototype;
+    var _proto = SkinParser.prototype;
     _proto.parse = function parse(context) {
-        var glTFResource = context.glTFResource, glTF = context.glTF; context.buffers;
+        var glTFResource = context.glTFResource, gltf = context.gltf; context.buffers;
         var entities = glTFResource.entities;
-        var gltfSkins = glTF.skins;
+        var gltfSkins = gltf.skins;
         if (!gltfSkins) return;
         var count = gltfSkins.length;
         var skins = new Array(count);
@@ -2105,8 +2183,8 @@ var GLTFSkinParser = /*#__PURE__*/ function(GLTFParser) {
             var skin = new Skin(name);
             skin.inverseBindMatrices.length = jointCount;
             // parse IBM
-            var accessor = glTF.accessors[inverseBindMatrices];
-            var buffer = GLTFUtil.getAccessorBuffer(context, glTF.bufferViews, accessor).data;
+            var accessor = gltf.accessors[inverseBindMatrices];
+            var buffer = GLTFUtil.getAccessorBuffer(context, gltf, accessor).data;
             for(var i1 = 0; i1 < jointCount; i1++){
                 var inverseBindMatrix = new Matrix();
                 inverseBindMatrix.copyFromArray(buffer, i1 * 16);
@@ -2141,7 +2219,7 @@ var GLTFSkinParser = /*#__PURE__*/ function(GLTFParser) {
     };
     _proto._findSkeletonRootBone = function _findSkeletonRootBone(joints, entities) {
         var paths = {};
-        for(var _iterator = _createForOfIteratorHelperLoose(joints), _step; !(_step = _iterator()).done;){
+        for(var _iterator = _create_for_of_iterator_helper_loose(joints), _step; !(_step = _iterator()).done;){
             var index = _step.value;
             var path = new Array();
             var entity = entities[index];
@@ -2167,24 +2245,24 @@ var GLTFSkinParser = /*#__PURE__*/ function(GLTFParser) {
             rootNode = entity1;
         }
     };
-    return GLTFSkinParser;
-}(GLTFParser);
+    return SkinParser;
+}(Parser);
 
-var GLTFTextureParser = /*#__PURE__*/ function(GLTFParser) {
-    _inherits(GLTFTextureParser, GLTFParser);
-    function GLTFTextureParser() {
-        return GLTFParser.apply(this, arguments);
+var TextureParser = /*#__PURE__*/ function(Parser) {
+    _inherits(TextureParser, Parser);
+    function TextureParser() {
+        return Parser.apply(this, arguments);
     }
-    var _proto = GLTFTextureParser.prototype;
+    var _proto = TextureParser.prototype;
     _proto.parse = function parse(context) {
         var _this = this;
-        var glTFResource = context.glTFResource, glTF = context.glTF, buffers = context.buffers;
+        var glTFResource = context.glTFResource, gltf = context.gltf, buffers = context.buffers;
         var engine = glTFResource.engine, url = glTFResource.url;
-        if (glTF.textures) {
+        if (gltf.textures) {
             var texturesPromiseInfo = context.texturesPromiseInfo;
-            AssetPromise.all(glTF.textures.map(function(param, index) {
+            AssetPromise.all(gltf.textures.map(function(param, index) {
                 var sampler = param.sampler, _param_source = param.source, source = _param_source === void 0 ? 0 : _param_source, textureName = param.name;
-                var _glTF_images_source = glTF.images[source], uri = _glTF_images_source.uri, bufferViewIndex = _glTF_images_source.bufferView, mimeType = _glTF_images_source.mimeType, imageName = _glTF_images_source.name;
+                var _gltf_images_source = gltf.images[source], uri = _gltf_images_source.uri, bufferViewIndex = _gltf_images_source.bufferView, mimeType = _gltf_images_source.mimeType, imageName = _gltf_images_source.name;
                 if (uri) {
                     // TODO: support ktx extension https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_texture_basisu/README.md
                     var index1 = uri.lastIndexOf(".");
@@ -2198,24 +2276,21 @@ var GLTFTextureParser = /*#__PURE__*/ function(GLTFParser) {
                             texture.name = textureName || imageName || "texture_" + index1;
                         }
                         if (sampler !== undefined) {
-                            _this._parseSampler(texture, glTF.samplers[sampler]);
+                            _this._parseSampler(texture, gltf.samplers[sampler]);
                         }
                         return texture;
                     });
                 } else {
-                    var bufferView = glTF.bufferViews[bufferViewIndex];
-                    var buffer = buffers[bufferView.buffer];
-                    var imageBuffer = new Uint8Array(buffer, bufferView.byteOffset, bufferView.byteLength);
-                    return GLTFUtil.loadImageBuffer(imageBuffer, mimeType).then(function(image) {
+                    var bufferView = gltf.bufferViews[bufferViewIndex];
+                    var bufferViewData = GLTFUtil.getBufferViewData(bufferView, buffers);
+                    return GLTFUtil.loadImageBuffer(bufferViewData, mimeType).then(function(image) {
                         var texture = new Texture2D(engine, image.width, image.height);
                         texture.setImageSource(image);
                         texture.generateMipmaps();
                         texture.name = textureName || imageName || "texture_" + index;
                         if (sampler !== undefined) {
-                            _this._parseSampler(texture, glTF.samplers[sampler]);
+                            _this._parseSampler(texture, gltf.samplers[sampler]);
                         }
-                        var bufferTextureRestoreInfo = new BufferTextureRestoreInfo(texture, bufferView, mimeType);
-                        context.contentRestorer.bufferTextures.push(bufferTextureRestoreInfo);
                         return texture;
                     });
                 }
@@ -2238,36 +2313,36 @@ var GLTFTextureParser = /*#__PURE__*/ function(GLTFParser) {
             }
         }
         if (wrapS) {
-            texture.wrapModeU = GLTFTextureParser._wrapMap[wrapS];
+            texture.wrapModeU = TextureParser._wrapMap[wrapS];
         }
         if (wrapT) {
-            texture.wrapModeV = GLTFTextureParser._wrapMap[wrapT];
+            texture.wrapModeV = TextureParser._wrapMap[wrapT];
         }
     };
-    return GLTFTextureParser;
-}(GLTFParser);
-var _obj;
-GLTFTextureParser._wrapMap = (_obj = {}, _obj[TextureWrapMode.CLAMP_TO_EDGE] = TextureWrapMode$1.Clamp, _obj[TextureWrapMode.MIRRORED_REPEAT] = TextureWrapMode$1.Mirror, _obj[TextureWrapMode.REPEAT] = TextureWrapMode$1.Repeat, _obj);
+    return TextureParser;
+}(Parser);
+(function() {
+    var _obj;
+    TextureParser._wrapMap = (_obj = {}, _obj[TextureWrapMode.CLAMP_TO_EDGE] = TextureWrapMode$1.Clamp, _obj[TextureWrapMode.MIRRORED_REPEAT] = TextureWrapMode$1.Mirror, _obj[TextureWrapMode.REPEAT] = TextureWrapMode$1.Repeat, _obj);
+})();
 
-var GLTFValidator = /*#__PURE__*/ function(GLTFParser1) {
-    _inherits(GLTFValidator, GLTFParser1);
-    function GLTFValidator() {
-        return GLTFParser1.apply(this, arguments);
+var Validator = /*#__PURE__*/ function(Parser1) {
+    _inherits(Validator, Parser1);
+    function Validator() {
+        return Parser1.apply(this, arguments);
     }
-    var _proto = GLTFValidator.prototype;
+    var _proto = Validator.prototype;
     _proto.parse = function parse(context) {
-        var _context_glTF = context.glTF, version = _context_glTF.asset.version, extensionsUsed = _context_glTF.extensionsUsed, extensionsRequired = _context_glTF.extensionsRequired;
-        var glTFVersion = Number(version);
-        if (!(glTFVersion >= 2 && glTFVersion < 3)) {
-            throw "Only support glTF 2.x.";
+        var _context_gltf = context.gltf, version = _context_gltf.asset.version, extensionsUsed = _context_gltf.extensionsUsed, extensionsRequired = _context_gltf.extensionsRequired;
+        var gltfVersion = Number(version);
+        if (!(gltfVersion >= 2 && gltfVersion < 3)) {
+            throw "Only support gltf 2.x.";
         }
-        var promises = [];
         if (extensionsUsed) {
             Logger.info("extensionsUsed: ", extensionsUsed);
             for(var i = 0; i < extensionsUsed.length; i++){
-                var extensionUsed = extensionsUsed[i];
-                if (!GLTFParser.hasExtensionParser(extensionUsed)) {
-                    Logger.warn("Extension " + extensionUsed + " is not implemented, you can customize this extension in gltf.");
+                if (!Parser.hasExtensionParser(extensionsUsed[i])) {
+                    Logger.warn("Extension " + extensionsUsed[i] + " is not implemented, you can customize this extension in gltf.");
                 }
             }
         }
@@ -2275,66 +2350,68 @@ var GLTFValidator = /*#__PURE__*/ function(GLTFParser1) {
             Logger.info("extensionsRequired: " + extensionsRequired);
             for(var i1 = 0; i1 < extensionsRequired.length; i1++){
                 var extensionRequired = extensionsRequired[i1];
-                if (!GLTFParser.hasExtensionParser(extensionRequired)) {
+                if (!Parser.hasExtensionParser(extensionRequired)) {
                     Logger.error("GLTF parser has not supported required extension " + extensionRequired + ".");
                 } else {
-                    promises.push(GLTFParser.executeExtensionsInitialize(extensionRequired));
+                    Parser.initialize(extensionRequired);
                 }
             }
         }
-        return AssetPromise.all(promises).then(null);
     };
-    return GLTFValidator;
-}(GLTFParser);
+    return Validator;
+}(Parser);
 
-/**
- * GLTF pipeline.
- */ var GLTFPipeline = /*#__PURE__*/ function() {
-    function GLTFPipeline() {
-        for(var _len = arguments.length, parsers = new Array(_len), _key = 0; _key < _len; _key++){
-            parsers[_key] = arguments[_key];
-        }
+var GLTFParser = /*#__PURE__*/ function() {
+    function GLTFParser(pipes) {
         var _this = this;
-        this._parsers = [];
-        parsers.forEach(function(pipe, index) {
-            _this._parsers[index] = new pipe();
+        this._pipes = [];
+        pipes.forEach(function(pipe, index) {
+            _this._pipes[index] = new pipe();
         });
     }
-    var _proto = GLTFPipeline.prototype;
-    /**
-   * @internal
-   */ _proto._parse = function _parse(context) {
+    var _proto = GLTFParser.prototype;
+    _proto.parse = function parse(context) {
         var _this = this;
         var glTFResource = context.glTFResource;
-        var lastParser;
+        var lastPipe;
         return new AssetPromise(function(resolve, reject) {
-            _this._parsers.forEach(function(parser) {
-                if (lastParser) {
-                    lastParser = lastParser.then(function() {
+            _this._pipes.forEach(function(parser) {
+                if (lastPipe) {
+                    lastPipe = lastPipe.then(function() {
                         return parser.parse(context);
                     });
-                    if (lastParser.cancel) {
-                        context.chainPromises.push(lastParser);
+                    if (lastPipe.cancel) {
+                        context.chainPromises.push(lastPipe);
                     }
                 } else {
-                    lastParser = parser.parse(context);
+                    lastPipe = parser.parse(context);
                 }
             });
-            if (lastParser) {
-                lastParser.then(function() {
+            if (lastPipe) {
+                lastPipe.then(function() {
                     resolve(glTFResource);
                 }).catch(reject);
             }
         });
     };
-    return GLTFPipeline;
+    return GLTFParser;
 }();
-/**
-   * Default pipeline.
-   */ GLTFPipeline.defaultPipeline = new GLTFPipeline(GLTFBufferParser, GLTFValidator, GLTFTextureParser, GLTFMaterialParser, GLTFMeshParser, GLTFEntityParser, GLTFSkinParser, GLTFAnimationParser, GLTFSceneParser);
+(function() {
+    GLTFParser.defaultPipeline = new GLTFParser([
+        BufferParser,
+        Validator,
+        TextureParser,
+        MaterialParser,
+        MeshParser,
+        EntityParser,
+        SkinParser,
+        AnimationParser,
+        SceneParser$1
+    ]);
+})();
 
 /**
- * Product after glTF parser, usually, `defaultSceneRoot` is only needed to use.
+ * Product after GLTF parser, usually, `defaultSceneRoot` is only needed to use.
  */ var GLTFResource = /*#__PURE__*/ function(EngineObject) {
     _inherits(GLTFResource, EngineObject);
     function GLTFResource(engine, url) {
@@ -2346,8 +2423,11 @@ var GLTFValidator = /*#__PURE__*/ function(GLTFParser1) {
     var _proto = GLTFResource.prototype;
     /**
    * @override
-   */ _proto._onDestroy = function _onDestroy() {
-        EngineObject.prototype._onDestroy.call(this);
+   */ _proto.destroy = function destroy() {
+        if (this._destroyed) {
+            return;
+        }
+        EngineObject.prototype.destroy.call(this);
         this.defaultSceneRoot.destroy();
         this.textures = null;
         this.materials = null;
@@ -2358,7 +2438,7 @@ var GLTFValidator = /*#__PURE__*/ function(GLTFParser1) {
         this.cameras = null;
         this.lights = null;
         this.sceneRoots = null;
-        this.extensionsData = null;
+        this.variants = null;
     };
     return GLTFResource;
 }(EngineObject);
@@ -2369,30 +2449,23 @@ var GLTFLoader = /*#__PURE__*/ function(Loader) {
         return Loader.apply(this, arguments);
     }
     var _proto = GLTFLoader.prototype;
-    /**
-   * @override
-   */ _proto.load = function load(item, resourceManager) {
+    _proto.load = function load(item, resourceManager) {
+        var _item_params;
         var url = item.url;
-        var params = item.params;
-        var context = new GLTFParserContext(url);
+        var context = new ParserContext(url);
         var glTFResource = new GLTFResource(resourceManager.engine, url);
-        var restorer = new GLTFContentRestorer(glTFResource);
         var masterPromiseInfo = context.masterPromiseInfo;
-        context.contentRestorer = restorer;
         context.glTFResource = glTFResource;
-        var _params_keepMeshData;
-        context.keepMeshData = (_params_keepMeshData = params == null ? void 0 : params.keepMeshData) != null ? _params_keepMeshData : false;
+        var _item_params_keepMeshData;
+        context.keepMeshData = (_item_params_keepMeshData = (_item_params = item.params) == null ? void 0 : _item_params.keepMeshData) != null ? _item_params_keepMeshData : false;
         masterPromiseInfo.onCancel(function() {
             var chainPromises = context.chainPromises;
-            for(var _iterator = _createForOfIteratorHelperLoose(chainPromises), _step; !(_step = _iterator()).done;){
+            for(var _iterator = _create_for_of_iterator_helper_loose(chainPromises), _step; !(_step = _iterator()).done;){
                 var promise = _step.value;
                 promise.cancel();
             }
         });
-        ((params == null ? void 0 : params.pipeline) || GLTFPipeline.defaultPipeline)._parse(context).then(function(glTFResource) {
-            resourceManager.addContentRestorer(restorer);
-            masterPromiseInfo.resolve(glTFResource);
-        }).catch(function(e) {
+        GLTFParser.defaultPipeline.parse(context).then(masterPromiseInfo.resolve).catch(function(e) {
             console.error(e);
             masterPromiseInfo.reject("Error loading glTF model from " + url + " .");
         });
@@ -2401,7 +2474,7 @@ var GLTFLoader = /*#__PURE__*/ function(Loader) {
     return GLTFLoader;
 }(Loader);
 GLTFLoader = __decorate([
-    resourceLoader(AssetType.GLTF, [
+    resourceLoader(AssetType.Prefab, [
         "gltf",
         "glb"
     ])
@@ -2648,37 +2721,75 @@ var HDRLoader = (_HDRLoader = /*#__PURE__*/ function(Loader) {
         color.a *= M;
     };
     return HDRLoader1;
-}(Loader), _HDRLoader._rightBottomBack = new Vector3(1.0, -1.0, -1.0), _HDRLoader._rightBottomFront = new Vector3(1.0, -1.0, 1.0), _HDRLoader._rightUpBack = new Vector3(1.0, 1.0, -1.0), _HDRLoader._rightUpFront = new Vector3(1.0, 1.0, 1.0), _HDRLoader._leftBottomBack = new Vector3(-1.0, -1.0, -1.0), _HDRLoader._leftBottomFront = new Vector3(-1.0, -1.0, 1.0), _HDRLoader._leftUpBack = new Vector3(-1.0, 1.0, -1.0), _HDRLoader._leftUpFront = new Vector3(-1.0, 1.0, 1.0), _HDRLoader._faceRight = [
-    _HDRLoader._rightBottomBack,
-    _HDRLoader._rightBottomFront,
-    _HDRLoader._rightUpBack,
-    _HDRLoader._rightUpFront
-], _HDRLoader._faceLeft = [
-    _HDRLoader._leftBottomFront,
-    _HDRLoader._leftBottomBack,
-    _HDRLoader._leftUpFront,
-    _HDRLoader._leftUpBack
-], _HDRLoader._faceUp = [
-    _HDRLoader._leftBottomFront,
-    _HDRLoader._rightBottomFront,
-    _HDRLoader._leftBottomBack,
-    _HDRLoader._rightBottomBack
-], _HDRLoader._faceBottom = [
-    _HDRLoader._leftUpBack,
-    _HDRLoader._rightUpBack,
-    _HDRLoader._leftUpFront,
-    _HDRLoader._rightUpFront
-], _HDRLoader._faceFront = [
-    _HDRLoader._leftBottomBack,
-    _HDRLoader._rightBottomBack,
-    _HDRLoader._leftUpBack,
-    _HDRLoader._rightUpBack
-], _HDRLoader._faceBack = [
-    _HDRLoader._rightBottomFront,
-    _HDRLoader._leftBottomFront,
-    _HDRLoader._rightUpFront,
-    _HDRLoader._leftUpFront
-], _HDRLoader._tempVector3 = new Vector3(), _HDRLoader._temp2Vector3 = new Vector3(), _HDRLoader._temp3Vector3 = new Vector3(), _HDRLoader._temp4Vector3 = new Vector3(), _HDRLoader._temp5Vector3 = new Vector3(), _HDRLoader);
+}(Loader), function() {
+    _HDRLoader._rightBottomBack = new Vector3(1.0, -1.0, -1.0);
+}(), function() {
+    _HDRLoader._rightBottomFront = new Vector3(1.0, -1.0, 1.0);
+}(), function() {
+    _HDRLoader._rightUpBack = new Vector3(1.0, 1.0, -1.0);
+}(), function() {
+    _HDRLoader._rightUpFront = new Vector3(1.0, 1.0, 1.0);
+}(), function() {
+    _HDRLoader._leftBottomBack = new Vector3(-1.0, -1.0, -1.0);
+}(), function() {
+    _HDRLoader._leftBottomFront = new Vector3(-1.0, -1.0, 1.0);
+}(), function() {
+    _HDRLoader._leftUpBack = new Vector3(-1.0, 1.0, -1.0);
+}(), function() {
+    _HDRLoader._leftUpFront = new Vector3(-1.0, 1.0, 1.0);
+}(), function() {
+    _HDRLoader._faceRight = [
+        _HDRLoader._rightBottomBack,
+        _HDRLoader._rightBottomFront,
+        _HDRLoader._rightUpBack,
+        _HDRLoader._rightUpFront
+    ];
+}(), function() {
+    _HDRLoader._faceLeft = [
+        _HDRLoader._leftBottomFront,
+        _HDRLoader._leftBottomBack,
+        _HDRLoader._leftUpFront,
+        _HDRLoader._leftUpBack
+    ];
+}(), function() {
+    _HDRLoader._faceUp = [
+        _HDRLoader._leftBottomFront,
+        _HDRLoader._rightBottomFront,
+        _HDRLoader._leftBottomBack,
+        _HDRLoader._rightBottomBack
+    ];
+}(), function() {
+    _HDRLoader._faceBottom = [
+        _HDRLoader._leftUpBack,
+        _HDRLoader._rightUpBack,
+        _HDRLoader._leftUpFront,
+        _HDRLoader._rightUpFront
+    ];
+}(), function() {
+    _HDRLoader._faceFront = [
+        _HDRLoader._leftBottomBack,
+        _HDRLoader._rightBottomBack,
+        _HDRLoader._leftUpBack,
+        _HDRLoader._rightUpBack
+    ];
+}(), function() {
+    _HDRLoader._faceBack = [
+        _HDRLoader._rightBottomFront,
+        _HDRLoader._leftBottomFront,
+        _HDRLoader._rightUpFront,
+        _HDRLoader._leftUpFront
+    ];
+}(), function() {
+    _HDRLoader._tempVector3 = new Vector3();
+}(), function() {
+    _HDRLoader._temp2Vector3 = new Vector3();
+}(), function() {
+    _HDRLoader._temp3Vector3 = new Vector3();
+}(), function() {
+    _HDRLoader._temp4Vector3 = new Vector3();
+}(), function() {
+    _HDRLoader._temp5Vector3 = new Vector3();
+}(), _HDRLoader);
 HDRLoader = __decorate([
     resourceLoader(AssetType.HDR, [
         "hdr"
@@ -3048,19 +3159,21 @@ MaterialLoader = __decorate([
 ], MaterialLoader);
 
 function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
-  }
+    for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+
+        if ("value" in descriptor) descriptor.writable = true;
+
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
 }
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
 
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  return Constructor;
+    return Constructor;
 }
 
 var BufferReader = /*#__PURE__*/ function() {
@@ -3169,7 +3282,7 @@ var BufferReader = /*#__PURE__*/ function() {
         if (byteLength < maxByteLength) this._offset++;
         return new Uint8Array(this._dataView.buffer, this._dataView.byteOffset + byteOffset, byteLength);
     };
-    _createClass(BufferReader, [
+    _create_class(BufferReader, [
         {
             key: "offset",
             get: function get() {
@@ -3179,12 +3292,14 @@ var BufferReader = /*#__PURE__*/ function() {
     ]);
     return BufferReader;
 }();
-BufferReader.imageMapping = {
-    0: "image/png",
-    1: "image/jpg",
-    2: "image/webp",
-    3: "ktx"
-};
+(function() {
+    BufferReader.imageMapping = {
+        0: "image/png",
+        1: "image/jpg",
+        2: "image/webp",
+        3: "ktx"
+    };
+})();
 
 var decoderMap = {};
 /**
@@ -3223,7 +3338,7 @@ var FileHeader = /*#__PURE__*/ function() {
         header.headerLength = nameUint8Array.byteLength + typeUint8Array.byteLength + 9;
         return header;
     };
-    _createClass(FileHeader, [
+    _create_class(FileHeader, [
         {
             key: "dataLength",
             get: function get() {
@@ -3442,38 +3557,36 @@ Texture2DDecoder = __decorate([
     decoder("Texture2D")
 ], Texture2DDecoder);
 
-function isNativeReflectConstruct() {
-  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-  if (Reflect.construct.sham) return false;
-  if (typeof Proxy === "function") return true;
-
-  try {
-    Date.prototype.toString.call(Reflect.construct(Date, [], function () { }));
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
 
-function construct(Parent, args, Class) {
-  if (isNativeReflectConstruct()) {
-    construct = Reflect.construct;
-  } else {
-    construct = function construct(Parent, args, Class) {
-      var a = [null];
-      a.push.apply(a, args);
-      var Constructor = Function.bind.apply(Parent, a);
-      var instance = new Constructor();
-      if (Class) _setPrototypeOf(instance, Class.prototype);
-      return instance;
-    };
-  }
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
 
-  return construct.apply(null, arguments);
+        return true;
+    } catch (e) {
+        return false;
+    }
 }
 
 function _construct(Parent, args, Class) {
-  return construct.apply(null, arguments);
+    if (_is_native_reflect_construct()) _construct = Reflect.construct;
+    else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [null];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+
+            if (Class) _set_prototype_of(instance, Class.prototype);
+
+            return instance;
+        };
+    }
+
+    return _construct.apply(null, arguments);
 }
 
 var ReflectionParser = /*#__PURE__*/ function() {
@@ -3588,7 +3701,9 @@ var ReflectionParser = /*#__PURE__*/ function() {
     };
     return ReflectionParser;
 }();
-ReflectionParser.customParseComponentHandles = new Map();
+(function() {
+    ReflectionParser.customParseComponentHandles = new Map();
+})();
 
 var PrefabParser = /*#__PURE__*/ function() {
     function PrefabParser() {}
@@ -3842,7 +3957,7 @@ var SceneParserContext = /*#__PURE__*/ function() {
     };
     _proto._organizeEntities = function _organizeEntities() {
         var _this_context = this.context, entityConfigMap = _this_context.entityConfigMap, entityMap = _this_context.entityMap, scene = _this_context.scene, rootIds = _this_context.rootIds;
-        for(var _iterator = _createForOfIteratorHelperLoose(rootIds), _step; !(_step = _iterator()).done;){
+        for(var _iterator = _create_for_of_iterator_helper_loose(rootIds), _step; !(_step = _iterator()).done;){
             var rootId = _step.value;
             PrefabParser.parseChildren(entityConfigMap, entityMap, rootId);
         }
@@ -4006,7 +4121,7 @@ var SourceFontLoader = /*#__PURE__*/ function(Loader) {
         });
     };
     _proto._registerFont = function _registerFont(fontName, fontUrl) {
-        return _asyncToGenerator(function() {
+        return _async_to_generator(function() {
             var fontFace;
             return __generator(this, function(_state) {
                 switch(_state.label){
@@ -4043,6 +4158,7 @@ var SpriteAtlasLoader = /*#__PURE__*/ function(Loader) {
         _this = Loader.apply(this, arguments) || this;
         _this._tempRect = new Rect();
         _this._tempVec2 = new Vector2();
+        _this._tempVec4 = new Vector4();
         return _this;
     }
     var _proto = SpriteAtlasLoader.prototype;
@@ -4060,57 +4176,65 @@ var SpriteAtlasLoader = /*#__PURE__*/ function(Loader) {
             }));
             chainPromises.push(configPromise);
             configPromise.then(function(atlasData) {
-                var atlasItems = atlasData.atlasItems, format = atlasData.format;
-                var atlasItemsLen = atlasItems.length;
-                var imagePromises = AssetPromise.all(atlasItems.map(function(param) {
-                    var img = param.img;
-                    return _this.request(GLTFUtil.parseRelativeUrl(item.url, img), _extends({}, item, {
-                        type: "image"
-                    }));
-                }));
-                chainPromises.push(imagePromises);
-                return imagePromises.then(function(imgs) {
-                    var engine = resourceManager.engine;
-                    // Generate a SpriteAtlas object.
-                    var tempRect = _this._tempRect, tempVec2 = _this._tempVec2;
-                    var spriteAtlas = new SpriteAtlas(engine);
-                    for(var i = 0; i < atlasItemsLen; i++){
-                        // Generate Texture2D according to configuration.
-                        var originalImg = imgs[i];
-                        var width = originalImg.width, height = originalImg.height;
-                        var texture = new Texture2D(engine, width, height, format);
-                        texture.setImageSource(originalImg);
-                        texture.generateMipmaps();
-                        // Generate all the sprites on this texture.
-                        var atlasItem = atlasItems[i];
-                        var sprites = atlasItem.sprites;
-                        var sourceWidthReciprocal = 1.0 / width;
-                        var sourceHeightReciprocal = 1.0 / height;
-                        for(var j = sprites.length - 1; j >= 0; j--){
-                            var atlasSprite = sprites[j];
-                            var region = atlasSprite.region, atlasRegionOffset = atlasSprite.atlasRegionOffset, atlasRegion = atlasSprite.atlasRegion, id = atlasSprite.id, pivot = atlasSprite.pivot;
-                            var sprite = new Sprite(engine, texture, region ? tempRect.set(region.x, region.y, region.w, region.h) : undefined, pivot ? tempVec2.set(pivot.x, pivot.y) : undefined, undefined, atlasSprite.name);
-                            sprite.atlasRegion.set(atlasRegion.x * sourceWidthReciprocal, atlasRegion.y * sourceHeightReciprocal, atlasRegion.w * sourceWidthReciprocal, atlasRegion.h * sourceHeightReciprocal);
-                            atlasSprite.atlasRotated && (sprite.atlasRotated = true);
-                            if (atlasRegionOffset) {
-                                var offsetLeft = atlasRegionOffset.x, offsetTop = atlasRegionOffset.y, offsetRight = atlasRegionOffset.z, offsetBottom = atlasRegionOffset.w;
-                                sprite.atlasRegionOffset.set(offsetLeft * sourceWidthReciprocal, offsetTop * sourceHeightReciprocal, offsetRight * sourceWidthReciprocal, offsetBottom * sourceHeightReciprocal);
+                var _loop = function(i) {
+                    var atlasItem = atlasItems[i];
+                    if (atlasItem.img) {
+                        chainPromises.push(resourceManager.load({
+                            url: atlasItem.img,
+                            type: AssetType.Texture2D,
+                            params: {
+                                format: format,
+                                mipmap: mipmap
                             }
-                            if (id !== undefined) {
+                        }).then(function(texture) {
+                            anisoLevel && (texture.anisoLevel = anisoLevel);
+                            filterMode !== undefined && (texture.filterMode = filterMode);
+                            wrapModeU !== undefined && (texture.wrapModeU = wrapModeU);
+                            wrapModeV !== undefined && (texture.wrapModeV = wrapModeV);
+                            for(var i = 0; i < atlasItem.sprites.length; i++){
                                 // @ts-ignore
-                                sprite._assetID = id;
+                                spriteAtlas._addSprite(_this._makeSprite(engine, atlasItem.sprites[i], texture));
                             }
+                        }).catch(reject));
+                    } else {
+                        for(var i1 = 0; i1 < atlasItem.sprites.length; i1++){
                             // @ts-ignore
-                            spriteAtlas._addSprite(sprite);
+                            spriteAtlas._addSprite(_this._makeSprite(engine, atlasItem.sprites[i1]));
                         }
                     }
+                };
+                var atlasItems = atlasData.atlasItems, mipmap = atlasData.mipmap, anisoLevel = atlasData.anisoLevel, filterMode = atlasData.filterMode, wrapModeU = atlasData.wrapModeU, wrapModeV = atlasData.wrapModeV, format = atlasData.format;
+                var atlasItemsLen = atlasItems ? atlasItems.length : 0;
+                var engine = resourceManager.engine;
+                var spriteAtlas = new SpriteAtlas(engine);
+                if (atlasItemsLen < 0) {
                     resolve(spriteAtlas);
-                });
-            }).catch(function(e) {
-                reject(e);
-            });
+                    return;
+                }
+                chainPromises.length = 0;
+                for(var i = 0; i < atlasItems.length; i++)_loop(i);
+                AssetPromise.all(chainPromises).then(function() {
+                    resolve(spriteAtlas);
+                }).catch(reject);
+            }).catch(reject);
         });
     };
+    _proto._makeSprite = function _makeSprite(engine, config, texture) {
+        // Generate a SpriteAtlas object.
+        var region = config.region, atlasRegionOffset = config.atlasRegionOffset, atlasRegion = config.atlasRegion, pivot = config.pivot, border = config.border;
+        var sprite = new Sprite(engine, texture, region ? this._tempRect.set(region.x, region.y, region.w, region.h) : undefined, pivot ? this._tempVec2.set(pivot.x, pivot.y) : undefined, border ? this._tempVec4.set(border.x, border.y, border.z, border.w) : undefined, config.name);
+        if (texture) {
+            var invW = 1 / texture.width;
+            var invH = 1 / texture.height;
+            sprite.atlasRegion.set(atlasRegion.x * invW, atlasRegion.y * invH, atlasRegion.w * invW, atlasRegion.h * invH);
+            if (atlasRegionOffset) {
+                var offsetLeft = atlasRegionOffset.x, offsetTop = atlasRegionOffset.y, offsetRight = atlasRegionOffset.z, offsetBottom = atlasRegionOffset.w;
+                sprite.atlasRegionOffset.set(offsetLeft * invW, offsetTop * invH, offsetRight * invW, offsetBottom * invH);
+            }
+            config.atlasRotated && (sprite.atlasRotated = true);
+        }
+        return sprite;
+    };
     return SpriteAtlasLoader;
 }(Loader);
 SpriteAtlasLoader = __decorate([
@@ -4131,13 +4255,19 @@ var SpriteLoader = /*#__PURE__*/ function(Loader) {
             _this.request(item.url, _extends({}, item, {
                 type: "json"
             })).then(function(data) {
-                // @ts-ignore
-                resourceManager.getResourceByRef(data.texture).then(function(texture) {
-                    var sprite = new Sprite(resourceManager.engine, texture);
-                    sprite.region = data.region;
-                    sprite.pivot = data.pivot;
-                    resolve(sprite);
-                });
+                if (data.belongToAtlas) {
+                    resourceManager// @ts-ignore
+                    .getResourceByRef(data.belongToAtlas).then(function(atlas) {
+                        resolve(atlas.getSprite(data.fullPath));
+                    }).catch(reject);
+                } else if (data.texture) {
+                    resourceManager// @ts-ignore
+                    .getResourceByRef(data.texture).then(function(texture) {
+                        resolve(new Sprite(resourceManager.engine, texture, data.region, data.pivot, data.border));
+                    }).catch(reject);
+                } else {
+                    resolve(new Sprite(resourceManager.engine, null, data.region, data.pivot, data.border));
+                }
             }).catch(reject);
         });
     };
@@ -4149,57 +4279,28 @@ SpriteLoader = __decorate([
     ], false)
 ], SpriteLoader);
 
-/**
- * @internal
- */ var Texture2DContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
-    _inherits(Texture2DContentRestorer, ContentRestorer);
-    function Texture2DContentRestorer(resource, url, requestConfig) {
-        var _this;
-        _this = ContentRestorer.call(this, resource) || this;
-        _this.url = url;
-        _this.requestConfig = requestConfig;
-        return _this;
-    }
-    var _proto = Texture2DContentRestorer.prototype;
-    /**
-   * @override
-   */ _proto.restoreContent = function restoreContent() {
-        var _this = this;
-        return request(this.url, this.requestConfig).then(function(image) {
-            var resource = _this.resource;
-            resource.setImageSource(image);
-            resource.generateMipmaps();
-            return resource;
-        });
-    };
-    return Texture2DContentRestorer;
-}(ContentRestorer);
-
 var Texture2DLoader = /*#__PURE__*/ function(Loader) {
     _inherits(Texture2DLoader, Loader);
     function Texture2DLoader() {
         return Loader.apply(this, arguments);
     }
     var _proto = Texture2DLoader.prototype;
-    /**
-   * @override
-   */ _proto.load = function load(item, resourceManager) {
+    _proto.load = function load(item, resourceManager) {
         var _this = this;
         return new AssetPromise(function(resolve, reject) {
-            var url = item.url;
-            var requestConfig = _extends({}, item, {
+            _this.request(item.url, _extends({}, item, {
                 type: "image"
-            });
-            _this.request(url, requestConfig).then(function(image) {
-                var params = item.params;
-                var texture = new Texture2D(resourceManager.engine, image.width, image.height, params == null ? void 0 : params.format, params == null ? void 0 : params.mipmap);
+            })).then(function(image) {
+                var _item_params;
+                var params = (_item_params = item.params) != null ? _item_params : {};
+                var texture = new Texture2D(resourceManager.engine, image.width, image.height, params.format, params.mipmap);
+                /** @ts-ignore */ if (!texture._platformTexture) return;
                 texture.setImageSource(image);
                 texture.generateMipmaps();
-                if (url.indexOf("data:") !== 0) {
-                    var index = url.lastIndexOf("/");
-                    texture.name = url.substring(index + 1);
+                if (item.url.indexOf("data:") !== 0) {
+                    var splitPath = item.url.split("/");
+                    texture.name = splitPath[splitPath.length - 1];
                 }
-                resourceManager.addContentRestorer(new Texture2DContentRestorer(texture, url, requestConfig));
                 resolve(texture);
             }).catch(function(e) {
                 reject(e);
@@ -4217,70 +4318,32 @@ Texture2DLoader = __decorate([
     ])
 ], Texture2DLoader);
 
-/**
- * @internal
- */ var TextureCubeContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
-    _inherits(TextureCubeContentRestorer, ContentRestorer);
-    function TextureCubeContentRestorer(resource, urls, requestConfig) {
-        var _this;
-        _this = ContentRestorer.call(this, resource) || this;
-        _this.urls = urls;
-        _this.requestConfig = requestConfig;
-        return _this;
-    }
-    var _proto = TextureCubeContentRestorer.prototype;
-    /**
-   * @override
-   */ _proto.restoreContent = function restoreContent() {
-        var _this = this;
-        return new AssetPromise(function(resolve, reject) {
-            Promise.all(_this.urls.map(function(url) {
-                return request(url, _this.requestConfig);
-            })).then(function(images) {
-                var resource = _this.resource;
-                for(var faceIndex = 0; faceIndex < 6; faceIndex++){
-                    resource.setImageSource(TextureCubeFace.PositiveX + faceIndex, images[faceIndex], 0);
-                }
-                resource.generateMipmaps();
-                resolve(resource);
-            }).catch(function(e) {
-                reject(e);
-            });
-        });
-    };
-    return TextureCubeContentRestorer;
-}(ContentRestorer);
-
 var TextureCubeLoader = /*#__PURE__*/ function(Loader) {
     _inherits(TextureCubeLoader, Loader);
     function TextureCubeLoader() {
         return Loader.apply(this, arguments);
     }
     var _proto = TextureCubeLoader.prototype;
-    /**
-   * @override
-   */ _proto.load = function load(item, resourceManager) {
+    _proto.load = function load(item, resourceManager) {
         var _this = this;
         return new AssetPromise(function(resolve, reject) {
-            var urls = item.urls;
-            var requestConfig = _extends({}, item, {
-                type: "image"
-            });
-            Promise.all(urls.map(function(url) {
-                return _this.request(url, requestConfig);
+            Promise.all(item.urls.map(function(url) {
+                return _this.request(url, _extends({}, item, {
+                    type: "image"
+                }));
             })).then(function(images) {
                 var _images_ = images[0], width = _images_.width, height = _images_.height;
                 if (width !== height) {
                     console.error("The cube texture must have the same width and height");
                     return;
                 }
-                var texture = new TextureCube(resourceManager.engine, width);
+                var tex = new TextureCube(resourceManager.engine, width);
+                /** @ts-ignore */ if (!tex._platformTexture) return;
                 for(var faceIndex = 0; faceIndex < 6; faceIndex++){
-                    texture.setImageSource(TextureCubeFace.PositiveX + faceIndex, images[faceIndex], 0);
+                    tex.setImageSource(TextureCubeFace.PositiveX + faceIndex, images[faceIndex], 0);
                 }
-                texture.generateMipmaps();
-                resourceManager.addContentRestorer(new TextureCubeContentRestorer(texture, urls, requestConfig));
-                resolve(texture);
+                tex.generateMipmaps();
+                resolve(tex);
             }).catch(function(e) {
                 reject(e);
             });
@@ -4294,30 +4357,6 @@ TextureCubeLoader = __decorate([
     ])
 ], TextureCubeLoader);
 
-var AnimationClipLoader = /*#__PURE__*/ function(Loader) {
-    _inherits(AnimationClipLoader, Loader);
-    function AnimationClipLoader() {
-        return Loader.apply(this, arguments);
-    }
-    var _proto = AnimationClipLoader.prototype;
-    _proto.load = function load(item, resourceManager) {
-        var _this = this;
-        return new AssetPromise(function(resolve, reject) {
-            _this.request(item.url, _extends({}, item, {
-                type: "arraybuffer"
-            })).then(function(data) {
-                return decode(data, resourceManager.engine);
-            }).catch(reject);
-        });
-    };
-    return AnimationClipLoader;
-}(Loader);
-AnimationClipLoader = __decorate([
-    resourceLoader(AssetType.AnimationClip, [
-        "ani"
-    ])
-], AnimationClipLoader);
-
 var SceneLoader = /*#__PURE__*/ function(Loader) {
     _inherits(SceneLoader, Loader);
     function SceneLoader() {
@@ -4403,7 +4442,7 @@ SceneLoader = __decorate([
         "prefab"
     ], true)
 ], SceneLoader);
-ReflectionParser.registerCustomParseComponent("TextRenderer", /*#__PURE__*/ _asyncToGenerator(function(instance, item, engine) {
+ReflectionParser.registerCustomParseComponent("TextRenderer", /*#__PURE__*/ _async_to_generator(function(instance, item, engine) {
     var props;
     return __generator(this, function(_state) {
         props = item.props;
@@ -4418,388 +4457,5 @@ ReflectionParser.registerCustomParseComponent("TextRenderer", /*#__PURE__*/ _asy
     });
 }));
 
-var _KHR_draco_mesh_compression;
-var KHR_draco_mesh_compression = (_KHR_draco_mesh_compression = /*#__PURE__*/ function(GLTFExtensionParser) {
-    _inherits(KHR_draco_mesh_compression1, GLTFExtensionParser);
-    function KHR_draco_mesh_compression1() {
-        return GLTFExtensionParser.apply(this, arguments);
-    }
-    var _proto = KHR_draco_mesh_compression1.prototype;
-    /**
-   * @override
-   */ _proto.initialize = function initialize() {
-        if (!KHR_draco_mesh_compression._decoder) {
-            KHR_draco_mesh_compression._decoder = new DRACODecoder();
-        }
-    };
-    /**
-   * @override
-   */ _proto.createAndParse = function createAndParse(context, schema, glTFPrimitive, glTFMesh) {
-        var _this = this;
-        var glTF = context.glTF, buffers = context.buffers, engine = context.glTFResource.engine;
-        var bufferViews = glTF.bufferViews, accessors = glTF.accessors;
-        var bufferViewIndex = schema.bufferView, gltfAttributeMap = schema.attributes;
-        var attributeMap = {};
-        var attributeTypeMap = {};
-        for(var attributeName in gltfAttributeMap){
-            attributeMap[attributeName] = gltfAttributeMap[attributeName];
-        }
-        for(var attributeName1 in glTFPrimitive.attributes){
-            if (gltfAttributeMap[attributeName1] !== undefined) {
-                var accessorDef = accessors[glTFPrimitive.attributes[attributeName1]];
-                attributeTypeMap[attributeName1] = GLTFUtil.getComponentType(accessorDef.componentType).name;
-            }
-        }
-        var indexAccessor = accessors[glTFPrimitive.indices];
-        var indexType = GLTFUtil.getComponentType(indexAccessor.componentType).name;
-        var taskConfig = {
-            attributeIDs: attributeMap,
-            attributeTypes: attributeTypeMap,
-            useUniqueIDs: true,
-            indexType: indexType
-        };
-        var buffer = GLTFUtil.getBufferViewData(bufferViews[bufferViewIndex], buffers);
-        return KHR_draco_mesh_compression._decoder.decode(buffer, taskConfig).then(function(decodedGeometry) {
-            var mesh = new ModelMesh(engine, glTFMesh.name);
-            return _this._parseMeshFromGLTFPrimitiveDraco(mesh, glTFMesh, glTFPrimitive, glTF, function(attributeSemantic) {
-                for(var j = 0; j < decodedGeometry.attributes.length; j++){
-                    if (decodedGeometry.attributes[j].name === attributeSemantic) {
-                        return decodedGeometry.attributes[j].array;
-                    }
-                }
-                return null;
-            }, function(attributeSemantic, shapeIndex) {
-                throw "BlendShape animation is not supported when using draco.";
-            }, function() {
-                return decodedGeometry.index.array;
-            }, context.keepMeshData);
-        });
-    };
-    _proto._parseMeshFromGLTFPrimitiveDraco = function _parseMeshFromGLTFPrimitiveDraco(mesh, gltfMesh, gltfPrimitive, gltf, getVertexBufferData, getBlendShapeData, getIndexBufferData, keepMeshData) {
-        var attributes = gltfPrimitive.attributes, targets = gltfPrimitive.targets, indices = gltfPrimitive.indices, mode = gltfPrimitive.mode;
-        var vertexCount;
-        var accessors = gltf.accessors;
-        var accessor = accessors[attributes["POSITION"]];
-        var positionBuffer = getVertexBufferData("POSITION");
-        var positions = GLTFUtil.floatBufferToVector3Array(positionBuffer);
-        mesh.setPositions(positions);
-        var bounds = mesh.bounds;
-        vertexCount = accessor.count;
-        if (accessor.min && accessor.max) {
-            bounds.min.copyFromArray(accessor.min);
-            bounds.max.copyFromArray(accessor.max);
-        } else {
-            var position = KHR_draco_mesh_compression._tempVector3;
-            var min = bounds.min, max = bounds.max;
-            min.set(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
-            max.set(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
-            var stride = positionBuffer.length / vertexCount;
-            for(var j = 0; j < vertexCount; j++){
-                var offset = j * stride;
-                position.copyFromArray(positionBuffer, offset);
-                Vector3.min(min, position, min);
-                Vector3.max(max, position, max);
-            }
-        }
-        for(var attributeSemantic in attributes){
-            if (attributeSemantic === "POSITION") {
-                continue;
-            }
-            var bufferData = getVertexBufferData(attributeSemantic);
-            switch(attributeSemantic){
-                case "NORMAL":
-                    var normals = GLTFUtil.floatBufferToVector3Array(bufferData);
-                    mesh.setNormals(normals);
-                    break;
-                case "TEXCOORD_0":
-                    var texturecoords = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords, 0);
-                    break;
-                case "TEXCOORD_1":
-                    var texturecoords1 = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords1, 1);
-                    break;
-                case "TEXCOORD_2":
-                    var texturecoords2 = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords2, 2);
-                    break;
-                case "TEXCOORD_3":
-                    var texturecoords3 = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords3, 3);
-                    break;
-                case "TEXCOORD_4":
-                    var texturecoords4 = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords4, 4);
-                    break;
-                case "TEXCOORD_5":
-                    var texturecoords5 = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords5, 5);
-                    break;
-                case "TEXCOORD_6":
-                    var texturecoords6 = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords6, 6);
-                    break;
-                case "TEXCOORD_7":
-                    var texturecoords7 = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords7, 7);
-                    break;
-                case "COLOR_0":
-                    var colors = GLTFUtil.floatBufferToColorArray(bufferData, accessors[attributes["COLOR_0"]].type === AccessorType.VEC3);
-                    mesh.setColors(colors);
-                    break;
-                case "TANGENT":
-                    var tangents = GLTFUtil.floatBufferToVector4Array(bufferData);
-                    mesh.setTangents(tangents);
-                    break;
-                case "JOINTS_0":
-                    var joints = GLTFUtil.floatBufferToVector4Array(bufferData);
-                    mesh.setBoneIndices(joints);
-                    break;
-                case "WEIGHTS_0":
-                    var weights = GLTFUtil.floatBufferToVector4Array(bufferData);
-                    mesh.setBoneWeights(weights);
-                    break;
-            }
-        }
-        // Indices
-        if (indices !== undefined) {
-            var indexAccessor = gltf.accessors[indices];
-            var indexData = getIndexBufferData();
-            mesh.setIndices(indexData);
-            mesh.addSubMesh(0, indexAccessor.count, mode);
-        } else {
-            mesh.addSubMesh(0, vertexCount, mode);
-        }
-        // BlendShapes
-        targets && GLTFMeshParser._createBlendShape(mesh, null, gltfMesh, targets, getBlendShapeData);
-        mesh.uploadData(!keepMeshData);
-        return Promise.resolve(mesh);
-    };
-    return KHR_draco_mesh_compression1;
-}(GLTFExtensionParser), _KHR_draco_mesh_compression._tempVector3 = new Vector3(), _KHR_draco_mesh_compression);
-KHR_draco_mesh_compression = __decorate([
-    registerGLTFExtension("KHR_draco_mesh_compression", GLTFExtensionMode.CreateAndParse)
-], KHR_draco_mesh_compression);
-
-var KHR_lights_punctual = /*#__PURE__*/ function(GLTFExtensionParser) {
-    _inherits(KHR_lights_punctual, GLTFExtensionParser);
-    function KHR_lights_punctual() {
-        return GLTFExtensionParser.apply(this, arguments);
-    }
-    var _proto = KHR_lights_punctual.prototype;
-    /**
-   * @override
-   */ _proto.additiveParse = function additiveParse(context, entity, extensionSchema) {
-        var lightsSchema = context.glTF.extensions.KHR_lights_punctual.lights;
-        var lightSchema = lightsSchema[extensionSchema.light];
-        var color = lightSchema.color, _lightSchema_intensity = lightSchema.intensity, intensity = _lightSchema_intensity === void 0 ? 1 : _lightSchema_intensity, type = lightSchema.type, range = lightSchema.range, spot = lightSchema.spot;
-        var glTFResource = context.glTFResource;
-        var light;
-        if (type === "directional") {
-            light = entity.addComponent(DirectLight);
-        } else if (type === "point") {
-            light = entity.addComponent(PointLight);
-        } else if (type === "spot") {
-            light = entity.addComponent(SpotLight);
-        }
-        if (color) {
-            light.color.set(color[0], color[1], color[2], 1);
-        }
-        light.intensity = intensity;
-        if (range && !_instanceof(light, DirectLight)) {
-            light.distance = range;
-        }
-        if (spot && _instanceof(light, SpotLight)) {
-            var _spot_innerConeAngle = spot.innerConeAngle, innerConeAngle = _spot_innerConeAngle === void 0 ? 0 : _spot_innerConeAngle, _spot_outerConeAngle = spot.outerConeAngle, outerConeAngle = _spot_outerConeAngle === void 0 ? Math.PI / 4 : _spot_outerConeAngle;
-            light.angle = innerConeAngle;
-            light.penumbra = outerConeAngle - innerConeAngle;
-        }
-        if (!glTFResource.lights) glTFResource.lights = [];
-        glTFResource.lights.push(light);
-    };
-    return KHR_lights_punctual;
-}(GLTFExtensionParser);
-KHR_lights_punctual = __decorate([
-    registerGLTFExtension("KHR_lights_punctual", GLTFExtensionMode.AdditiveParse)
-], KHR_lights_punctual);
-
-var KHR_materials_clearcoat = /*#__PURE__*/ function(GLTFExtensionParser) {
-    _inherits(KHR_materials_clearcoat, GLTFExtensionParser);
-    function KHR_materials_clearcoat() {
-        return GLTFExtensionParser.apply(this, arguments);
-    }
-    var _proto = KHR_materials_clearcoat.prototype;
-    /**
-   * @override
-   */ _proto.additiveParse = function additiveParse(context, material, schema) {
-        var textures = context.glTFResource.textures;
-        var _schema_clearcoatFactor = schema.clearcoatFactor, clearcoatFactor = _schema_clearcoatFactor === void 0 ? 0 : _schema_clearcoatFactor, clearcoatTexture = schema.clearcoatTexture, _schema_clearcoatRoughnessFactor = schema.clearcoatRoughnessFactor, clearcoatRoughnessFactor = _schema_clearcoatRoughnessFactor === void 0 ? 0 : _schema_clearcoatRoughnessFactor, clearcoatRoughnessTexture = schema.clearcoatRoughnessTexture, clearcoatNormalTexture = schema.clearcoatNormalTexture;
-        material.clearCoat = clearcoatFactor;
-        material.clearCoatRoughness = clearcoatRoughnessFactor;
-        if (clearcoatTexture) {
-            material.clearCoatTexture = textures[clearcoatTexture.index];
-            GLTFMaterialParser._checkOtherTextureTransform(clearcoatTexture, "Clear coat");
-        }
-        if (clearcoatRoughnessTexture) {
-            material.clearCoatRoughnessTexture = textures[clearcoatRoughnessTexture.index];
-            GLTFMaterialParser._checkOtherTextureTransform(clearcoatRoughnessTexture, "Clear coat roughness");
-        }
-        if (clearcoatNormalTexture) {
-            material.clearCoatNormalTexture = textures[clearcoatNormalTexture.index];
-            GLTFMaterialParser._checkOtherTextureTransform(clearcoatNormalTexture, "Clear coat normal");
-        }
-    };
-    return KHR_materials_clearcoat;
-}(GLTFExtensionParser);
-KHR_materials_clearcoat = __decorate([
-    registerGLTFExtension("KHR_materials_clearcoat", GLTFExtensionMode.AdditiveParse)
-], KHR_materials_clearcoat);
-
-var KHR_materials_pbrSpecularGlossiness = /*#__PURE__*/ function(GLTFExtensionParser) {
-    _inherits(KHR_materials_pbrSpecularGlossiness, GLTFExtensionParser);
-    function KHR_materials_pbrSpecularGlossiness() {
-        return GLTFExtensionParser.apply(this, arguments);
-    }
-    var _proto = KHR_materials_pbrSpecularGlossiness.prototype;
-    /**
-   * @override
-   */ _proto.createAndParse = function createAndParse(context, schema, ownerSchema) {
-        var _context_glTFResource = context.glTFResource, engine = _context_glTFResource.engine, textures = _context_glTFResource.textures;
-        var material = new PBRSpecularMaterial(engine);
-        var diffuseFactor = schema.diffuseFactor, diffuseTexture = schema.diffuseTexture, specularFactor = schema.specularFactor, glossinessFactor = schema.glossinessFactor, specularGlossinessTexture = schema.specularGlossinessTexture;
-        if (diffuseFactor) {
-            material.baseColor = new Color(Color.linearToGammaSpace(diffuseFactor[0]), Color.linearToGammaSpace(diffuseFactor[1]), Color.linearToGammaSpace(diffuseFactor[2]), diffuseFactor[3]);
-        }
-        if (diffuseTexture) {
-            material.baseTexture = textures[diffuseTexture.index];
-            GLTFParser.executeExtensionsAdditiveAndParse(diffuseTexture.extensions, context, material, diffuseTexture);
-        }
-        if (specularFactor) {
-            material.specularColor = new Color(Color.linearToGammaSpace(specularFactor[0]), Color.linearToGammaSpace(specularFactor[1]), Color.linearToGammaSpace(specularFactor[2]));
-        }
-        if (glossinessFactor !== undefined) {
-            material.glossiness = glossinessFactor;
-        }
-        if (specularGlossinessTexture) {
-            material.specularGlossinessTexture = textures[specularGlossinessTexture.index];
-            GLTFMaterialParser._checkOtherTextureTransform(specularGlossinessTexture, "Specular glossiness");
-        }
-        material.name = ownerSchema.name;
-        GLTFMaterialParser._parseStandardProperty(context, material, ownerSchema);
-        return material;
-    };
-    return KHR_materials_pbrSpecularGlossiness;
-}(GLTFExtensionParser);
-KHR_materials_pbrSpecularGlossiness = __decorate([
-    registerGLTFExtension("KHR_materials_pbrSpecularGlossiness", GLTFExtensionMode.CreateAndParse)
-], KHR_materials_pbrSpecularGlossiness);
-
-var KHR_materials_unlit = /*#__PURE__*/ function(GLTFExtensionParser) {
-    _inherits(KHR_materials_unlit, GLTFExtensionParser);
-    function KHR_materials_unlit() {
-        return GLTFExtensionParser.apply(this, arguments);
-    }
-    var _proto = KHR_materials_unlit.prototype;
-    /**
-   * @override
-   */ _proto.createAndParse = function createAndParse(context, _, ownerSchema) {
-        var engine = context.glTFResource.engine;
-        var material = new UnlitMaterial(engine);
-        material.name = ownerSchema.name;
-        GLTFMaterialParser._parseStandardProperty(context, material, ownerSchema);
-        return material;
-    };
-    return KHR_materials_unlit;
-}(GLTFExtensionParser);
-KHR_materials_unlit = __decorate([
-    registerGLTFExtension("KHR_materials_unlit", GLTFExtensionMode.CreateAndParse)
-], KHR_materials_unlit);
-
-var KHR_mesh_quantization = /*#__PURE__*/ function(GLTFExtensionParser) {
-    _inherits(KHR_mesh_quantization, GLTFExtensionParser);
-    function KHR_mesh_quantization() {
-        return GLTFExtensionParser.apply(this, arguments);
-    }
-    return KHR_mesh_quantization;
-}(GLTFExtensionParser);
-KHR_mesh_quantization = __decorate([
-    registerGLTFExtension("KHR_mesh_quantization", GLTFExtensionMode.AdditiveParse)
-], KHR_mesh_quantization);
-
-var KHR_texture_transform = /*#__PURE__*/ function(GLTFExtensionParser) {
-    _inherits(KHR_texture_transform, GLTFExtensionParser);
-    function KHR_texture_transform() {
-        return GLTFExtensionParser.apply(this, arguments);
-    }
-    var _proto = KHR_texture_transform.prototype;
-    /**
-   * @override
-   */ _proto.additiveParse = function additiveParse(context, material, schema) {
-        var offset = schema.offset, rotation = schema.rotation, scale = schema.scale, texCoord = schema.texCoord;
-        if (offset) {
-            material.tilingOffset.z = offset[0];
-            material.tilingOffset.w = offset[1];
-        }
-        if (scale) {
-            material.tilingOffset.x = scale[0];
-            material.tilingOffset.y = scale[1];
-        }
-        if (rotation) {
-            Logger.warn("rotation in KHR_texture_transform is not supported now");
-        }
-        if (texCoord) {
-            Logger.warn("texCoord in KHR_texture_transform is not supported now");
-        }
-    };
-    return KHR_texture_transform;
-}(GLTFExtensionParser);
-KHR_texture_transform = __decorate([
-    registerGLTFExtension("KHR_texture_transform", GLTFExtensionMode.AdditiveParse)
-], KHR_texture_transform);
-
-var GalaceanMaterialsRemap = /*#__PURE__*/ function(GLTFExtensionParser) {
-    _inherits(GalaceanMaterialsRemap, GLTFExtensionParser);
-    function GalaceanMaterialsRemap() {
-        return GLTFExtensionParser.apply(this, arguments);
-    }
-    var _proto = GalaceanMaterialsRemap.prototype;
-    /**
-   * @override
-   */ _proto.createAndParse = function createAndParse(context, schema) {
-        var engine = context.glTFResource.engine;
-        // @ts-ignore
-        return engine.resourceManager.getResourceByRef(schema);
-    };
-    return GalaceanMaterialsRemap;
-}(GLTFExtensionParser);
-GalaceanMaterialsRemap = __decorate([
-    registerGLTFExtension("OASIS_materials_remap", GLTFExtensionMode.CreateAndParse)
-], GalaceanMaterialsRemap);
-
-var OASIS_animation_event = /*#__PURE__*/ function(GLTFExtensionParser) {
-    _inherits(OASIS_animation_event, GLTFExtensionParser);
-    function OASIS_animation_event() {
-        return GLTFExtensionParser.apply(this, arguments);
-    }
-    var _proto = OASIS_animation_event.prototype;
-    /**
-   * @override
-   */ _proto.additiveParse = function additiveParse(context, animationClip, schema) {
-        context.glTFResource.engine;
-        var events = schema.events;
-        events.map(function(eventData) {
-            var event = new AnimationEvent();
-            event.functionName = eventData.functionName;
-            event.time = eventData.time;
-            event.parameter = eventData.parameter;
-            animationClip.addEvent(event);
-        });
-    };
-    return OASIS_animation_event;
-}(GLTFExtensionParser);
-OASIS_animation_event = __decorate([
-    registerGLTFExtension("OASIS_animation_event", GLTFExtensionMode.AdditiveParse)
-], OASIS_animation_event);
-
-export { AnimationClipDecoder, ComponentMap, EditorTextureLoader, GLTFAnimationParser, GLTFBufferParser, GLTFEntityParser, GLTFExtensionMode, GLTFExtensionParser, GLTFMaterialParser, GLTFMeshParser, GLTFParser, GLTFParserContext, GLTFPipeline, GLTFResource, GLTFSceneParser, GLTFSkinParser, GLTFTextureParser, GLTFUtil, GLTFValidator, InterpolableValueType, MeshDecoder, MeshLoader$1 as MeshLoader, PrefabParser, ReflectionParser, SceneParser, Texture2DDecoder, decode, parseSingleKTX, registerGLTFExtension };
+export { AnimationClipDecoder, ComponentMap, EditorTextureLoader, GLTFResource, InterpolableValueType, MeshDecoder, MeshLoader$1 as MeshLoader, PrefabParser, ReflectionParser, SceneParser, Texture2DDecoder, decode, parseSingleKTX };
 //# sourceMappingURL=module.js.map