@galacean/engine-loader 0.9.0-beta.80 → 1.0.0-alpha.6

package/dist/module.js

@@ -1,7 +1,7 @@
-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 { 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 { SphericalHarmonics3, Vector2, Vector3, Vector4, Color, Quaternion, Matrix, Rect } from '@galacean/engine-math';
-import { DRACODecoder } from '@galacean/engine-draco';
 import { GLCompressedTextureInternalFormat } from '@galacean/engine-rhi-webgl';
+import { DRACODecoder } from '@galacean/engine-draco';
 
 function extends_() {
   extends_ = Object.assign || function (target) {
@@ -103,10 +103,10 @@ function __generator(thisArg, body) {
     }
 }
 
-var AnimatorControllerLoader = /*#__PURE__*/ function(Loader) {
-    _inherits(AnimatorControllerLoader, Loader);
+var AnimatorControllerLoader = /*#__PURE__*/ function(Loader1) {
+    _inherits(AnimatorControllerLoader, Loader1);
     function AnimatorControllerLoader() {
-        return Loader.apply(this, arguments);
+        return Loader1.apply(this, arguments);
     }
     var _proto = AnimatorControllerLoader.prototype;
     _proto.load = function load(item, resourceManager) {
@@ -127,13 +127,16 @@ var AnimatorControllerLoader = /*#__PURE__*/ function(Loader) {
                         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;
+                            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 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
@@ -359,52 +362,192 @@ 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 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 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 _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;
+    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);
         });
-        promiseInfo.promise = promise;
-        return promise;
     };
-    return ParserContext;
-}();
+    _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 BufferInfo = function BufferInfo(data, interleaved, stride) {
+ */ 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 = [];
+};
+/**
+ * @internal
+ */ var BufferRestoreInfo = function BufferRestoreInfo(buffer, data) {
+    this.buffer = buffer;
     this.data = data;
-    this.interleaved = interleaved;
-    this.stride = stride;
-    this.vertexBindingInfos = {};
 };
 /**
  * @internal
- */ var PromiseInfo = function PromiseInfo() {
+ */ 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;
 };
 
 /**
@@ -554,6 +697,54 @@ 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() {
@@ -662,18 +853,18 @@ var TextureWrapMode;
                 throw new Error("Galacean.GLTFLoader: Unsupported normalized accessor component type.");
         }
     };
-    GLTFUtil.getAccessorBuffer = function getAccessorBuffer(context, gltf, accessor) {
+    GLTFUtil.getAccessorBuffer = function getAccessorBuffer(context, bufferViews, accessor) {
         var buffers = context.buffers;
-        var bufferViews = gltf.bufferViews;
         var componentType = accessor.componentType;
         var bufferView = bufferViews[accessor.bufferView];
-        var buffer = buffers[bufferView.buffer];
+        var bufferIndex = bufferView.buffer;
+        var buffer = buffers[bufferIndex];
         var bufferByteOffset = bufferView.byteOffset || 0;
         var byteOffset = accessor.byteOffset || 0;
         var TypedArray = GLTFUtil.getComponentType(componentType);
-        var dataElmentSize = GLTFUtil.getAccessorTypeSize(accessor.type);
+        var dataElementSize = GLTFUtil.getAccessorTypeSize(accessor.type);
         var dataElementBytes = TypedArray.BYTES_PER_ELEMENT;
-        var elementStride = dataElmentSize * dataElementBytes;
+        var elementStride = dataElementSize * dataElementBytes;
         var accessorCount = accessor.count;
         var bufferStride = bufferView.byteStride;
         var bufferInfo;
@@ -688,24 +879,25 @@ 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 * dataElmentSize;
+            var count1 = accessorCount * dataElementSize;
             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) {
-            var data2 = GLTFUtil.processingSparseData(gltf, accessor, buffers, bufferInfo.data);
-            bufferInfo = new BufferInfo(data2, false, bufferInfo.stride);
+            GLTFUtil.processingSparseData(bufferViews, accessor, buffers, bufferInfo);
         }
         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;
@@ -755,38 +947,46 @@ var TextureWrapMode;
         return typedArray;
     };
     GLTFUtil.getBufferViewData = function getBufferViewData(bufferView, buffers) {
-        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);
+        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);
     };
     /**
    * Get accessor data.
-   */ GLTFUtil.processingSparseData = function processingSparseData(gltf, accessor, buffers, originData) {
-        var bufferViews = gltf.bufferViews;
+   */ GLTFUtil.processingSparseData = function processingSparseData(bufferViews, accessor, buffers, bufferInfo) {
+        var restoreInfo = bufferInfo.restoreInfo;
         var accessorTypeSize = GLTFUtil.getAccessorTypeSize(accessor.type);
         var TypedArray = GLTFUtil.getComponentType(accessor.componentType);
-        var data = originData.slice();
+        var data = bufferInfo.data.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 indicesArrayBuffer = buffers[indicesBufferView.buffer];
-        var valuesArrayBuffer = buffers[valuesBufferView.buffer];
+        var indicesBufferIndex = indicesBufferView.buffer;
+        var valuesBufferIndex = valuesBufferView.buffer;
+        var indicesArrayBuffer = buffers[indicesBufferIndex];
+        var valuesArrayBuffer = buffers[valuesBufferIndex];
         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 indicesArray = new IndexTypeArray(indicesArrayBuffer, indicesByteOffset, indicesByteLength / IndexTypeArray.BYTES_PER_ELEMENT);
-        var valuesArray = new TypedArray(valuesArrayBuffer, valuesByteOffset, valuesByteLength / TypedArray.BYTES_PER_ELEMENT);
+        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);
         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];
             }
         }
-        return data;
+        bufferInfo.data = data;
     };
     GLTFUtil.getIndexFormat = function getIndexFormat(type) {
         switch(type){
@@ -884,7 +1084,7 @@ var TextureWrapMode;
     };
     /**
    * Parse the glb format.
-   */ GLTFUtil.parseGLB = function parseGLB(glb) {
+   */ GLTFUtil.parseGLB = function parseGLB(context, glb) {
         var UINT32_LENGTH = 4;
         var GLB_HEADER_MAGIC = 0x46546c67; // 'glTF'
         var GLB_HEADER_LENGTH = 12;
@@ -912,10 +1112,11 @@ 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);
@@ -926,10 +1127,11 @@ 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
         };
     };
@@ -944,12 +1146,6 @@ var TextureWrapMode;
     return GLTFUtil;
 }();
 
-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 _arrayWithoutHoles(arr) {
   if (Array.isArray(arr)) return _arrayLikeToArray(arr);
 }
@@ -962,604 +1158,325 @@ 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 _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 _toConsumableArray(arr) {
   return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
 }
 
-var Parser = /*#__PURE__*/ function() {
-    function Parser() {}
-    Parser.parseEngineResource = function parseEngineResource(extensionName, extensionSchema, parseResource, context) {
+/**
+ * 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) {
         for(var _len = arguments.length, extra = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++){
             extra[_key - 4] = arguments[_key];
         }
-        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(_toConsumableArray(extra)));
-            }
+        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();
         }
     };
-    Parser.createEngineResource = function createEngineResource(extensionName, extensionSchema, context) {
+    /**
+   * 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 = {};
         for(var _len = arguments.length, extra = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++){
             extra[_key - 3] = arguments[_key];
         }
-        var parsers = Parser._extensionParsers[extensionName];
-        if (parsers == null ? void 0 : parsers.length) {
-            var _parsers_;
-            return (_parsers_ = parsers[0]).createEngineResource.apply(_parsers_, [
+        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,
+                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,
-                context
+                ownerSchema
             ].concat(_toConsumableArray(extra)));
         }
     };
-    Parser.hasExtensionParser = function hasExtensionParser(extensionName) {
-        var parsers = Parser._extensionParsers[extensionName];
-        return !!(parsers == null ? void 0 : parsers.length);
+    /**
+   * 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.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();
+    /**
+   * 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;
+                }
             }
         }
     };
     /**
    * @internal
-   */ Parser._addExtensionParser = function _addExtensionParser(extensionName, extensionParser) {
-        if (!Parser._extensionParsers[extensionName]) {
-            Parser._extensionParsers[extensionName] = [];
+   */ 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._extensionParsers[extensionName].push(extensionParser);
     };
-    return Parser;
+    return GLTFParser;
 }();
-Parser._extensionParsers = {};
+GLTFParser._extensionParsers = {};
 /**
  * Declare ExtensionParser's decorator.
  * @param extensionName - Extension name
- */ function registerExtension(extensionName) {
+ */ function registerGLTFExtension(extensionName, mode) {
     return function(parser) {
         var extensionParser = new parser();
-        Parser._addExtensionParser(extensionName, extensionParser);
+        extensionParser._mode = mode;
+        GLTFParser._addExtensionParser(extensionName, extensionParser);
     };
 }
 
-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];
-        }
-    };
-    _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 null;
-    };
-    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 GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
+    _inherits(GLTFAnimationParser, GLTFParser1);
+    function GLTFAnimationParser() {
+        return GLTFParser1.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();
-        }
-    };
-    _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];
+    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;
         }
-        for(var attributeName1 in gltfPrimitive.attributes){
-            if (gltfAttributeMap[attributeName1] !== undefined) {
-                var accessorDef = accessors[gltfPrimitive.attributes[attributeName1]];
-                attributeTypeMap[attributeName1] = GLTFUtil.getComponentType(accessorDef.componentType).name;
+        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);
         }
-        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;
+        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 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.");
-                    }
+    /**
+   * @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;
             }
-            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;
+            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 MaterialAlphaMode.BLEND:
-                    material.isTransparent = true;
+                case AnimationSamplerInterpolation.Step:
+                    samplerInterpolation = InterpolationType.Step;
                     break;
-                case MaterialAlphaMode.MASK:
-                    material.alphaCutoff = alphaCutoff != null ? alphaCutoff : 0.5;
+                case AnimationSamplerInterpolation.Linear:
+                    samplerInterpolation = InterpolationType.Linear;
                     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;
-                })
+            input[input.length - 1];
+            sampleDataCollection.push({
+                type: outputAccessor.type,
+                interpolation: samplerInterpolation,
+                input: input,
+                output: output,
+                outputSize: outputStride
             });
         }
-    };
-    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 _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.");
-}
-
-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;
             }
-            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);
+            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;
             }
-            animationClips[i] = animationClip;
-            animationsIndices[i] = {
-                name: name,
-                index: i
-            };
+            var curve = this._addCurve(target.path, gltfChannel, sampleDataCollection);
+            animationClip.addCurveBinding(relativePath, ComponentType, propertyName, curve);
         }
-        glTFResource.animations = animationClips;
-        // @ts-ignore for editor
-        glTFResource._animationsIndices = animationsIndices;
-        animationClipsPromiseInfo.resolve(animationClips);
-        return animationClipsPromiseInfo.promise;
     };
-    _proto._addCurve = function _addCurve(animationchannelTargetPath, gltfChannel, sampleDataCollection) {
+    GLTFAnimationParser._addCurve = function _addCurve(animationChannelTargetPath, gltfChannel, sampleDataCollection) {
         var sampleData = sampleDataCollection[gltfChannel.sampler];
         var input = sampleData.input, output = sampleData.output, outputSize = sampleData.outputSize;
-        switch(animationchannelTargetPath){
+        switch(animationChannelTargetPath){
             case AnimationChannelTargetPath.TRANSLATION:
             case AnimationChannelTargetPath.SCALE:
                 {
@@ -1624,35 +1541,42 @@ var AnimationParser = /*#__PURE__*/ function(Parser) {
                 }
         }
     };
-    return AnimationParser;
-}(Parser);
+    return GLTFAnimationParser;
+}(GLTFParser);
 
-var BufferParser = /*#__PURE__*/ function(Parser) {
-    _inherits(BufferParser, Parser);
-    function BufferParser() {
-        return Parser.apply(this, arguments);
+var GLTFBufferParser = /*#__PURE__*/ function(GLTFParser) {
+    _inherits(GLTFBufferParser, GLTFParser);
+    function GLTFBufferParser() {
+        return GLTFParser.apply(this, arguments);
     }
-    var _proto = BufferParser.prototype;
+    var _proto = GLTFBufferParser.prototype;
     _proto.parse = function parse(context) {
-        var glTFResource = context.glTFResource;
+        var glTFResource = context.glTFResource, contentRestorer = context.contentRestorer;
         var url = glTFResource.url;
-        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;
+        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;
                 context.buffers = buffers;
             });
         } else {
             return request(url, {
                 type: "json"
-            }).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(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(buffers) {
                     context.buffers = buffers;
                 });
@@ -1663,24 +1587,24 @@ var BufferParser = /*#__PURE__*/ function(Parser) {
         var index = url.lastIndexOf(".");
         return url.substring(index + 1, index + 4) === "glb";
     };
-    return BufferParser;
-}(Parser);
+    return GLTFBufferParser;
+}(GLTFParser);
 
-var EntityParser = /*#__PURE__*/ function(Parser) {
-    _inherits(EntityParser, Parser);
-    function EntityParser() {
-        return Parser.apply(this, arguments);
+var GLTFEntityParser = /*#__PURE__*/ function(GLTFParser) {
+    _inherits(GLTFEntityParser, GLTFParser);
+    function GLTFEntityParser() {
+        return GLTFParser.apply(this, arguments);
     }
-    var _proto = EntityParser.prototype;
+    var _proto = GLTFEntityParser.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 || "" + EntityParser._defaultName + i);
+            var entity = new Entity(engine, gltfNode.name || "" + GLTFEntityParser._defaultName + i);
             var transform = entity.transform;
             if (matrix) {
                 var localMatrix = transform.localMatrix;
@@ -1704,7 +1628,7 @@ var EntityParser = /*#__PURE__*/ function(Parser) {
         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;
@@ -1718,7 +1642,7 @@ var EntityParser = /*#__PURE__*/ function(Parser) {
         }
     };
     _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 = [];
@@ -1738,94 +1662,210 @@ var EntityParser = /*#__PURE__*/ function(Parser) {
         glTFResource.sceneRoots = sceneRoots;
         glTFResource.defaultSceneRoot = sceneRoots[sceneID];
     };
-    return EntityParser;
-}(Parser);
-/** @internal */ EntityParser._defaultName = "_GLTF_ENTITY_";
+    return GLTFEntityParser;
+}(GLTFParser);
+/** @internal */ GLTFEntityParser._defaultName = "_GLTF_ENTITY_";
 
-var MeshParser = /*#__PURE__*/ function(Parser1) {
-    _inherits(MeshParser, Parser1);
-    function MeshParser() {
-        return Parser1.apply(this, arguments);
+var GLTFMaterialParser = /*#__PURE__*/ function(GLTFParser1) {
+    _inherits(GLTFMaterialParser, GLTFParser1);
+    function GLTFMaterialParser() {
+        return GLTFParser1.apply(this, arguments);
     }
-    var _proto = MeshParser.prototype;
+    var _proto = GLTFMaterialParser.prototype;
     _proto.parse = function parse(context) {
-        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 glTF = context.glTF, glTFResource = context.glTFResource, materialsPromiseInfo = context.materialsPromiseInfo;
+        if (!glTF.materials) return;
         var engine = glTFResource.engine;
-        if (!gltf.meshes) return;
-        var meshesPromiseInfo = context.meshesPromiseInfo;
-        var meshPromises = [];
-        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;
+        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;
+        });
     };
-    _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;
-        var engine = mesh.engine;
-        var vertexElements = new Array();
+    /**
+   * @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;
+        var meshesPromiseInfo = context.meshesPromiseInfo;
+        var meshPromises = [];
+        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) {
+        var accessors = gltf.accessors;
+        context.buffers;
+        var attributes = gltfPrimitive.attributes, targets = gltfPrimitive.targets, indices = gltfPrimitive.indices, mode = gltfPrimitive.mode;
+        var engine = mesh.engine;
+        var vertexElements = new Array();
         var vertexCount;
         var bufferBindIndex = 0;
         for(var attribute in attributes){
             var accessor = accessors[attributes[attribute]];
-            var accessorBuffer = GLTFUtil.getAccessorBuffer(context, gltf, accessor);
-            var dataElmentSize = GLTFUtil.getAccessorTypeSize(accessor.type);
+            var accessorBuffer = GLTFUtil.getAccessorBuffer(context, gltf.bufferViews, accessor);
+            var dataElementSize = 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, dataElmentSize, accessor.normalized);
+            var elementFormat = GLTFUtil.getElementFormat(accessor.componentType, dataElementSize, accessor.normalized);
             if (accessorBuffer.interleaved) {
                 var byteOffset = accessor.byteOffset || 0;
                 var stride = accessorBuffer.stride;
@@ -1837,6 +1877,7 @@ var MeshParser = /*#__PURE__*/ function(Parser1) {
                         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++;
@@ -1847,6 +1888,7 @@ var MeshParser = /*#__PURE__*/ function(Parser1) {
                 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++;
             }
@@ -1858,7 +1900,7 @@ var MeshParser = /*#__PURE__*/ function(Parser1) {
                     min.copyFromArray(accessor.min);
                     max.copyFromArray(accessor.max);
                 } else {
-                    var position = MeshParser._tempVector3;
+                    var position = GLTFMeshParser._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;
@@ -1870,9 +1912,9 @@ var MeshParser = /*#__PURE__*/ function(Parser1) {
                     }
                 }
                 if (accessor.normalized) {
-                    var sacleFactor = GLTFUtil.getNormalizedComponentScale(accessor.componentType);
-                    min.scale(sacleFactor);
-                    max.scale(sacleFactor);
+                    var scaleFactor = GLTFUtil.getNormalizedComponentScale(accessor.componentType);
+                    min.scale(scaleFactor);
+                    max.scale(scaleFactor);
                 }
             }
         }
@@ -1880,175 +1922,68 @@ var MeshParser = /*#__PURE__*/ function(Parser1) {
         // Indices
         if (indices !== undefined) {
             var indexAccessor = gltf.accessors[indices];
-            var indexData = getIndexBufferData();
-            mesh.setIndices(indexData);
+            var accessorBuffer1 = GLTFUtil.getAccessorBuffer(context, gltf.bufferViews, indexAccessor);
+            mesh.setIndices(accessorBuffer1.data);
             mesh.addSubMesh(0, indexAccessor.count, mode);
+            meshRestoreInfo.indexBuffer = accessorBuffer1.restoreInfo;
         } else {
             mesh.addSubMesh(0, vertexCount, mode);
         }
         // BlendShapes
-        targets && this._createBlendShape(mesh, gltfMesh, targets, getBlendShapeData);
+        targets && GLTFMeshParser._createBlendShape(mesh, meshRestoreInfo, gltfMesh, targets, getBlendShapeData);
         mesh.uploadData(!keepMeshData);
         return Promise.resolve(mesh);
     };
-    _proto._createBlendShape = function _createBlendShape(mesh, glTFMesh, glTFTargets, getBlendShapeData) {
+    /**
+   * @internal
+   */ GLTFMeshParser._createBlendShape = function _createBlendShape(mesh, meshRestoreInfo, 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 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 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 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));
         }
     };
-    /**
-   * @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);
-MeshParser._tempVector3 = new Vector3();
+    return GLTFMeshParser;
+}(GLTFParser);
+GLTFMeshParser._tempVector3 = new Vector3();
 
-var SceneParser$1 = /*#__PURE__*/ function(Parser1) {
-    _inherits(SceneParser, Parser1);
-    function SceneParser() {
-        return Parser1.apply(this, arguments);
+var GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
+    _inherits(GLTFSceneParser, GLTFParser1);
+    function GLTFSceneParser() {
+        return GLTFParser1.apply(this, arguments);
     }
-    var _proto = SceneParser.prototype;
+    var _proto = GLTFSceneParser.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, gltfCameras = gltf.cameras;
+        var nodes = glTF.nodes, cameras = 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, _gltfNode_extensions = gltfNode.extensions, extensions = _gltfNode_extensions === void 0 ? {} : _gltfNode_extensions;
-            var KHR_lights_punctual = extensions.KHR_lights_punctual;
+            var glTFNode = nodes[i];
+            var cameraID = glTFNode.camera, meshID = glTFNode.mesh, extensions = glTFNode.extensions;
             var entity = entities[i];
             if (cameraID !== undefined) {
-                this._createCamera(glTFResource, gltfCameras[cameraID], entity);
+                this._createCamera(glTFResource, cameras[cameraID], entity);
             }
             if (meshID !== undefined) {
-                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);
+                this._createRenderer(context, glTFNode, entity);
             }
+            GLTFParser.executeExtensionsAdditiveAndParse(extensions, context, entity, glTFNode);
         }
         if (glTFResource.defaultSceneRoot) {
             this._createAnimator(context);
         }
-        gltf.extensions && delete gltf.extensions["OASIS_materials_remap"];
-        AssetPromise.all(promises).then(function() {
-            return defaultSceneRootPromiseInfo.resolve(glTFResource.defaultSceneRoot);
-        }).catch(defaultSceneRootPromiseInfo.reject);
+        defaultSceneRootPromiseInfo.resolve(glTFResource.defaultSceneRoot);
         return defaultSceneRootPromiseInfo.promise;
     };
     _proto._createCamera = function _createCamera(context, cameraSchema, entity) {
@@ -2084,8 +2019,16 @@ var SceneParser$1 = /*#__PURE__*/ function(Parser1) {
         // @todo: use engine camera by default
         camera.enabled = false;
     };
-    _proto._createRenderer = function _createRenderer(context, gltfNode, entity) {
-        var _loop = function(i) {
+    _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];
             var mesh = meshes[meshID][i];
             var renderer = void 0;
             if (skinID !== undefined || blendShapeWeights) {
@@ -2103,32 +2046,11 @@ var SceneParser$1 = /*#__PURE__*/ function(Parser1) {
                 renderer = entity.addComponent(MeshRenderer);
                 renderer.mesh = mesh;
             }
-            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);
+            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);
+        }
     };
     _proto._createAnimator = function _createAnimator(context) {
         if (!context.hasSkinned && !context.glTFResource.animations) {
@@ -2155,25 +2077,25 @@ var SceneParser$1 = /*#__PURE__*/ function(Parser1) {
             }
         }
     };
-    SceneParser._getDefaultMaterial = function _getDefaultMaterial(engine) {
-        if (!SceneParser._defaultMaterial) {
-            SceneParser._defaultMaterial = new BlinnPhongMaterial(engine);
+    GLTFSceneParser._getDefaultMaterial = function _getDefaultMaterial(engine) {
+        if (!GLTFSceneParser._defaultMaterial) {
+            GLTFSceneParser._defaultMaterial = new BlinnPhongMaterial(engine);
         }
-        return SceneParser._defaultMaterial;
+        return GLTFSceneParser._defaultMaterial;
     };
-    return SceneParser;
-}(Parser);
+    return GLTFSceneParser;
+}(GLTFParser);
 
-var SkinParser = /*#__PURE__*/ function(Parser) {
-    _inherits(SkinParser, Parser);
-    function SkinParser() {
-        return Parser.apply(this, arguments);
+var GLTFSkinParser = /*#__PURE__*/ function(GLTFParser) {
+    _inherits(GLTFSkinParser, GLTFParser);
+    function GLTFSkinParser() {
+        return GLTFParser.apply(this, arguments);
     }
-    var _proto = SkinParser.prototype;
+    var _proto = GLTFSkinParser.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);
@@ -2183,8 +2105,8 @@ var SkinParser = /*#__PURE__*/ function(Parser) {
             var skin = new Skin(name);
             skin.inverseBindMatrices.length = jointCount;
             // parse IBM
-            var accessor = gltf.accessors[inverseBindMatrices];
-            var buffer = GLTFUtil.getAccessorBuffer(context, gltf, accessor).data;
+            var accessor = glTF.accessors[inverseBindMatrices];
+            var buffer = GLTFUtil.getAccessorBuffer(context, glTF.bufferViews, accessor).data;
             for(var i1 = 0; i1 < jointCount; i1++){
                 var inverseBindMatrix = new Matrix();
                 inverseBindMatrix.copyFromArray(buffer, i1 * 16);
@@ -2245,24 +2167,24 @@ var SkinParser = /*#__PURE__*/ function(Parser) {
             rootNode = entity1;
         }
     };
-    return SkinParser;
-}(Parser);
+    return GLTFSkinParser;
+}(GLTFParser);
 
-var TextureParser = /*#__PURE__*/ function(Parser) {
-    _inherits(TextureParser, Parser);
-    function TextureParser() {
-        return Parser.apply(this, arguments);
+var GLTFTextureParser = /*#__PURE__*/ function(GLTFParser) {
+    _inherits(GLTFTextureParser, GLTFParser);
+    function GLTFTextureParser() {
+        return GLTFParser.apply(this, arguments);
     }
-    var _proto = TextureParser.prototype;
+    var _proto = GLTFTextureParser.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(".");
@@ -2276,21 +2198,24 @@ var TextureParser = /*#__PURE__*/ function(Parser) {
                             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 bufferViewData = GLTFUtil.getBufferViewData(bufferView, buffers);
-                    return GLTFUtil.loadImageBuffer(bufferViewData, mimeType).then(function(image) {
+                    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 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;
                     });
                 }
@@ -2313,34 +2238,36 @@ var TextureParser = /*#__PURE__*/ function(Parser) {
             }
         }
         if (wrapS) {
-            texture.wrapModeU = TextureParser._wrapMap[wrapS];
+            texture.wrapModeU = GLTFTextureParser._wrapMap[wrapS];
         }
         if (wrapT) {
-            texture.wrapModeV = TextureParser._wrapMap[wrapT];
+            texture.wrapModeV = GLTFTextureParser._wrapMap[wrapT];
         }
     };
-    return TextureParser;
-}(Parser);
+    return GLTFTextureParser;
+}(GLTFParser);
 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);
+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);
 
-var Validator = /*#__PURE__*/ function(Parser1) {
-    _inherits(Validator, Parser1);
-    function Validator() {
-        return Parser1.apply(this, arguments);
+var GLTFValidator = /*#__PURE__*/ function(GLTFParser1) {
+    _inherits(GLTFValidator, GLTFParser1);
+    function GLTFValidator() {
+        return GLTFParser1.apply(this, arguments);
     }
-    var _proto = Validator.prototype;
+    var _proto = GLTFValidator.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++){
-                if (!Parser.hasExtensionParser(extensionsUsed[i])) {
-                    Logger.warn("Extension " + extensionsUsed[i] + " is not implemented, you can customize this extension in gltf.");
+                var extensionUsed = extensionsUsed[i];
+                if (!GLTFParser.hasExtensionParser(extensionUsed)) {
+                    Logger.warn("Extension " + extensionUsed + " is not implemented, you can customize this extension in gltf.");
                 }
             }
         }
@@ -2348,66 +2275,66 @@ var Validator = /*#__PURE__*/ function(Parser1) {
             Logger.info("extensionsRequired: " + extensionsRequired);
             for(var i1 = 0; i1 < extensionsRequired.length; i1++){
                 var extensionRequired = extensionsRequired[i1];
-                if (!Parser.hasExtensionParser(extensionRequired)) {
+                if (!GLTFParser.hasExtensionParser(extensionRequired)) {
                     Logger.error("GLTF parser has not supported required extension " + extensionRequired + ".");
                 } else {
-                    Parser.initialize(extensionRequired);
+                    promises.push(GLTFParser.executeExtensionsInitialize(extensionRequired));
                 }
             }
         }
+        return AssetPromise.all(promises).then(null);
     };
-    return Validator;
-}(Parser);
+    return GLTFValidator;
+}(GLTFParser);
 
-var GLTFParser = /*#__PURE__*/ function() {
-    function GLTFParser(pipes) {
+/**
+ * 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 _this = this;
-        this._pipes = [];
-        pipes.forEach(function(pipe, index) {
-            _this._pipes[index] = new pipe();
+        this._parsers = [];
+        parsers.forEach(function(pipe, index) {
+            _this._parsers[index] = new pipe();
         });
     }
-    var _proto = GLTFParser.prototype;
-    _proto.parse = function parse(context) {
+    var _proto = GLTFPipeline.prototype;
+    /**
+   * @internal
+   */ _proto._parse = function _parse(context) {
         var _this = this;
         var glTFResource = context.glTFResource;
-        var lastPipe;
+        var lastParser;
         return new AssetPromise(function(resolve, reject) {
-            _this._pipes.forEach(function(parser) {
-                if (lastPipe) {
-                    lastPipe = lastPipe.then(function() {
+            _this._parsers.forEach(function(parser) {
+                if (lastParser) {
+                    lastParser = lastParser.then(function() {
                         return parser.parse(context);
                     });
-                    if (lastPipe.cancel) {
-                        context.chainPromises.push(lastPipe);
+                    if (lastParser.cancel) {
+                        context.chainPromises.push(lastParser);
                     }
                 } else {
-                    lastPipe = parser.parse(context);
+                    lastParser = parser.parse(context);
                 }
             });
-            if (lastPipe) {
-                lastPipe.then(function() {
+            if (lastParser) {
+                lastParser.then(function() {
                     resolve(glTFResource);
                 }).catch(reject);
             }
         });
     };
-    return GLTFParser;
+    return GLTFPipeline;
 }();
-GLTFParser.defaultPipeline = new GLTFParser([
-    BufferParser,
-    Validator,
-    TextureParser,
-    MaterialParser,
-    MeshParser,
-    EntityParser,
-    SkinParser,
-    AnimationParser,
-    SceneParser$1
-]);
+/**
+   * Default pipeline.
+   */ GLTFPipeline.defaultPipeline = new GLTFPipeline(GLTFBufferParser, GLTFValidator, GLTFTextureParser, GLTFMaterialParser, GLTFMeshParser, GLTFEntityParser, GLTFSkinParser, GLTFAnimationParser, GLTFSceneParser);
 
 /**
- * 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) {
@@ -2419,11 +2346,8 @@ GLTFParser.defaultPipeline = new GLTFParser([
     var _proto = GLTFResource.prototype;
     /**
    * @override
-   */ _proto.destroy = function destroy() {
-        if (this._destroyed) {
-            return;
-        }
-        EngineObject.prototype.destroy.call(this);
+   */ _proto._onDestroy = function _onDestroy() {
+        EngineObject.prototype._onDestroy.call(this);
         this.defaultSceneRoot.destroy();
         this.textures = null;
         this.materials = null;
@@ -2434,7 +2358,7 @@ GLTFParser.defaultPipeline = new GLTFParser([
         this.cameras = null;
         this.lights = null;
         this.sceneRoots = null;
-        this.variants = null;
+        this.extensionsData = null;
     };
     return GLTFResource;
 }(EngineObject);
@@ -2445,15 +2369,19 @@ var GLTFLoader = /*#__PURE__*/ function(Loader) {
         return Loader.apply(this, arguments);
     }
     var _proto = GLTFLoader.prototype;
-    _proto.load = function load(item, resourceManager) {
-        var _item_params;
+    /**
+   * @override
+   */ _proto.load = function load(item, resourceManager) {
         var url = item.url;
-        var context = new ParserContext(url);
+        var params = item.params;
+        var context = new GLTFParserContext(url);
         var glTFResource = new GLTFResource(resourceManager.engine, url);
+        var restorer = new GLTFContentRestorer(glTFResource);
         var masterPromiseInfo = context.masterPromiseInfo;
+        context.contentRestorer = restorer;
         context.glTFResource = glTFResource;
-        var _item_params_keepMeshData;
-        context.keepMeshData = (_item_params_keepMeshData = (_item_params = item.params) == null ? void 0 : _item_params.keepMeshData) != null ? _item_params_keepMeshData : false;
+        var _params_keepMeshData;
+        context.keepMeshData = (_params_keepMeshData = params == null ? void 0 : params.keepMeshData) != null ? _params_keepMeshData : false;
         masterPromiseInfo.onCancel(function() {
             var chainPromises = context.chainPromises;
             for(var _iterator = _createForOfIteratorHelperLoose(chainPromises), _step; !(_step = _iterator()).done;){
@@ -2461,7 +2389,10 @@ var GLTFLoader = /*#__PURE__*/ function(Loader) {
                 promise.cancel();
             }
         });
-        GLTFParser.defaultPipeline.parse(context).then(masterPromiseInfo.resolve).catch(function(e) {
+        ((params == null ? void 0 : params.pipeline) || GLTFPipeline.defaultPipeline)._parse(context).then(function(glTFResource) {
+            resourceManager.addContentRestorer(restorer);
+            masterPromiseInfo.resolve(glTFResource);
+        }).catch(function(e) {
             console.error(e);
             masterPromiseInfo.reject("Error loading glTF model from " + url + " .");
         });
@@ -2470,7 +2401,7 @@ var GLTFLoader = /*#__PURE__*/ function(Loader) {
     return GLTFLoader;
 }(Loader);
 GLTFLoader = __decorate([
-    resourceLoader(AssetType.Prefab, [
+    resourceLoader(AssetType.GLTF, [
         "gltf",
         "glb"
     ])
@@ -4218,28 +4149,57 @@ 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;
-    _proto.load = function load(item, resourceManager) {
+    /**
+   * @override
+   */ _proto.load = function load(item, resourceManager) {
         var _this = this;
         return new AssetPromise(function(resolve, reject) {
-            _this.request(item.url, _extends({}, item, {
+            var url = item.url;
+            var requestConfig = _extends({}, item, {
                 type: "image"
-            })).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;
+            });
+            _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);
                 texture.setImageSource(image);
                 texture.generateMipmaps();
-                if (item.url.indexOf("data:") !== 0) {
-                    var splitPath = item.url.split("/");
-                    texture.name = splitPath[splitPath.length - 1];
+                if (url.indexOf("data:") !== 0) {
+                    var index = url.lastIndexOf("/");
+                    texture.name = url.substring(index + 1);
                 }
+                resourceManager.addContentRestorer(new Texture2DContentRestorer(texture, url, requestConfig));
                 resolve(texture);
             }).catch(function(e) {
                 reject(e);
@@ -4257,33 +4217,71 @@ 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;
-    _proto.load = function load(item, resourceManager) {
+    /**
+   * @override
+   */ _proto.load = function load(item, resourceManager) {
         var _this = this;
         return new AssetPromise(function(resolve, reject) {
-            Promise.all(item.urls.map(function(url) {
-                return _this.request(url, _extends({}, item, {
-                    type: "image"
-                }));
+            var urls = item.urls;
+            var requestConfig = _extends({}, item, {
+                type: "image"
+            });
+            Promise.all(urls.map(function(url) {
+                return _this.request(url, requestConfig);
             })).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 tex = new TextureCube(resourceManager.engine, width);
-                /** @ts-ignore */ if (!tex._platformTexture) return;
+                var texture = new TextureCube(resourceManager.engine, width);
                 for(var faceIndex = 0; faceIndex < 6; faceIndex++){
-                    tex.setImageSource(TextureCubeFace.PositiveX + faceIndex, images[faceIndex], 0);
+                    texture.setImageSource(TextureCubeFace.PositiveX + faceIndex, images[faceIndex], 0);
                 }
-                tex.generateMipmaps();
-                resolve(tex);
-            }).catch(function(e) {
+                texture.generateMipmaps();
+                resourceManager.addContentRestorer(new TextureCubeContentRestorer(texture, urls, requestConfig));
+                resolve(texture);
+            }).catch(function(e) {
                 reject(e);
             });
         });
@@ -4296,6 +4294,30 @@ 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() {
@@ -4396,5 +4418,388 @@ ReflectionParser.registerCustomParseComponent("TextRenderer", /*#__PURE__*/ _asy
     });
 }));
 
-export { AnimationClipDecoder, ComponentMap, EditorTextureLoader, GLTFResource, InterpolableValueType, MeshDecoder, MeshLoader$1 as MeshLoader, PrefabParser, ReflectionParser, SceneParser, Texture2DDecoder, decode, parseSingleKTX };
+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 };
 //# sourceMappingURL=module.js.map