@galacean/engine-loader 1.1.0-beta.16 → 1.1.0-beta.17

package/dist/main.js

@@ -120,116 +120,116 @@ var BufferReader = /*#__PURE__*/ function() {
         this.data = data;
         this._dataView = new DataView(data.buffer, data.byteOffset + byteOffset, byteLength != null ? byteLength : data.byteLength - byteOffset);
         this._littleEndian = littleEndian;
-        this._offset = 0;
+        this._position = 0;
         this._baseOffset = byteOffset;
     }
     var _proto = BufferReader.prototype;
     _proto.nextUint8 = function nextUint8() {
-        var value = this._dataView.getUint8(this._offset);
-        this._offset += 1;
+        var value = this._dataView.getUint8(this._position);
+        this._position += 1;
         return value;
     };
     _proto.nextUint16 = function nextUint16() {
-        var value = this._dataView.getUint16(this._offset, this._littleEndian);
-        this._offset += 2;
+        var value = this._dataView.getUint16(this._position, this._littleEndian);
+        this._position += 2;
         return value;
     };
     _proto.nextUint32 = function nextUint32() {
-        var value = this._dataView.getUint32(this._offset, this._littleEndian);
-        this._offset += 4;
+        var value = this._dataView.getUint32(this._position, this._littleEndian);
+        this._position += 4;
         return value;
     };
     _proto.nextInt32 = function nextInt32() {
-        var value = this._dataView.getInt32(this._offset, this._littleEndian);
-        this._offset += 4;
+        var value = this._dataView.getInt32(this._position, this._littleEndian);
+        this._position += 4;
         return value;
     };
     _proto.nextInt32Array = function nextInt32Array(len) {
-        var value = new Int32Array(this.data.buffer, this._offset + this._dataView.byteOffset, len);
-        this._offset += 4 * len;
+        var value = new Int32Array(this.data.buffer, this._position + this._dataView.byteOffset, len);
+        this._position += 4 * len;
         return value;
     };
     _proto.nextFloat32 = function nextFloat32() {
-        var value = this._dataView.getFloat32(this._offset, this._littleEndian);
-        this._offset += 4;
+        var value = this._dataView.getFloat32(this._position, this._littleEndian);
+        this._position += 4;
         return value;
     };
     _proto.nextFloat32Array = function nextFloat32Array(len) {
-        var value = new Float32Array(this.data.buffer, this._offset + this._dataView.byteOffset, len);
-        this._offset += 4 * len;
+        var value = new Float32Array(this.data.buffer, this._position + this._dataView.byteOffset, len);
+        this._position += 4 * len;
         return value;
     };
     _proto.nextUint32Array = function nextUint32Array(len) {
-        var value = new Uint32Array(this.data.buffer, this._offset + this._dataView.byteOffset, len);
-        this._offset += 4 * len;
+        var value = new Uint32Array(this.data.buffer, this._position + this._dataView.byteOffset, len);
+        this._position += 4 * len;
         return value;
     };
     _proto.nextUint8Array = function nextUint8Array(len) {
-        var value = new Uint8Array(this.data.buffer, this._offset + this._dataView.byteOffset, len);
-        this._offset += len;
+        var value = new Uint8Array(this.data.buffer, this._position + this._dataView.byteOffset, len);
+        this._position += len;
         return value;
     };
     _proto.nextUint64 = function nextUint64() {
-        var left = this._dataView.getUint32(this._offset, this._littleEndian);
-        var right = this._dataView.getUint32(this._offset + 4, this._littleEndian);
+        var left = this._dataView.getUint32(this._position, this._littleEndian);
+        var right = this._dataView.getUint32(this._position + 4, this._littleEndian);
         var value = left + Math.pow(2, 32) * right;
-        this._offset += 8;
+        this._position += 8;
         return value;
     };
     _proto.nextStr = function nextStr() {
         var strByteLength = this.nextUint16();
-        var uint8Array = new Uint8Array(this.data.buffer, this._offset + this._dataView.byteOffset, strByteLength);
-        this._offset += strByteLength;
+        var uint8Array = new Uint8Array(this.data.buffer, this._position + this._dataView.byteOffset, strByteLength);
+        this._position += strByteLength;
         return engineCore.Utils.decodeText(uint8Array);
     };
     /**
    * image data 放在最后
    */ _proto.nextImageData = function nextImageData(count) {
-        return new Uint8Array(this.data.buffer, this.data.byteOffset + this._offset);
+        return new Uint8Array(this.data.buffer, this.data.byteOffset + this._position);
     };
     _proto.nextImagesData = function nextImagesData(count) {
         var imagesLen = new Array(count);
         // Start offset of Uint32Array should be a multiple of 4. ref: https://stackoverflow.com/questions/15417310/why-typed-array-constructors-require-offset-to-be-multiple-of-underlying-type-si
         for(var i = 0; i < count; i++){
-            var len = this._dataView.getUint32(this._offset, this._littleEndian);
+            var len = this._dataView.getUint32(this._position, this._littleEndian);
             imagesLen[i] = len;
-            this._offset += 4;
+            this._position += 4;
         }
         var imagesData = [];
         for(var i1 = 0; i1 < count; i1++){
             var len1 = imagesLen[i1];
-            var buffer = new Uint8Array(this.data.buffer, this._dataView.byteOffset + this._offset, len1);
-            this._offset += len1;
+            var buffer = new Uint8Array(this.data.buffer, this._dataView.byteOffset + this._position, len1);
+            this._position += len1;
             imagesData.push(buffer);
         }
         return imagesData;
     };
     _proto.skip = function skip(bytes) {
-        this._offset += bytes;
+        this._position += bytes;
         return this;
     };
     _proto.scan = function scan(maxByteLength, term) {
         if (term === void 0) term = 0x00;
-        var byteOffset = this._offset;
+        var byteOffset = this._position;
         var byteLength = 0;
-        while(this._dataView.getUint8(this._offset) !== term && byteLength < maxByteLength){
+        while(this._dataView.getUint8(this._position) !== term && byteLength < maxByteLength){
             byteLength++;
-            this._offset++;
+            this._position++;
         }
-        if (byteLength < maxByteLength) this._offset++;
+        if (byteLength < maxByteLength) this._position++;
         return new Uint8Array(this._dataView.buffer, this._dataView.byteOffset + byteOffset, byteLength);
     };
     _create_class(BufferReader, [
         {
             key: "position",
             get: function get() {
-                return this._offset;
+                return this._position;
             }
         },
         {
             key: "offset",
             get: function get() {
-                return this._offset + this._baseOffset;
+                return this._position + this._baseOffset;
             }
         }
     ]);
@@ -293,75 +293,74 @@ exports.MeshDecoder = /*#__PURE__*/ function() {
             var encodedMeshData = JSON.parse(jsonDataString);
             // @ts-ignore Vector3 is not compatible with {x: number, y: number, z: number}.
             encodedMeshData.bounds && modelMesh.bounds.copyFrom(encodedMeshData.bounds);
-            var offset = Math.ceil(bufferReader.position / 4) * 4;
+            var offset = Math.ceil(bufferReader.offset / 4) * 4 + bufferReader.data.byteOffset;
             var buffer = bufferReader.data.buffer;
-            var byteOffset = bufferReader.data.byteOffset;
-            var float32Array = new Float32Array(buffer, encodedMeshData.positions.start + offset + byteOffset, (encodedMeshData.positions.end - encodedMeshData.positions.start) / 4);
+            var float32Array = new Float32Array(buffer, encodedMeshData.positions.start + offset, (encodedMeshData.positions.end - encodedMeshData.positions.start) / 4);
             var vertexCount = float32Array.length / 3;
             var positions = float32ArrayToVector3(float32Array, vertexCount);
             modelMesh.setPositions(positions);
             if (encodedMeshData.normals) {
-                var float32Array1 = new Float32Array(buffer, encodedMeshData.normals.start + offset + byteOffset, (encodedMeshData.normals.end - encodedMeshData.normals.start) / 4);
+                var float32Array1 = new Float32Array(buffer, encodedMeshData.normals.start + offset, (encodedMeshData.normals.end - encodedMeshData.normals.start) / 4);
                 var normals = float32ArrayToVector3(float32Array1, vertexCount);
                 modelMesh.setNormals(normals);
             }
             if (encodedMeshData.uvs) {
-                var float32Array2 = new Float32Array(buffer, encodedMeshData.uvs.start + offset + byteOffset, (encodedMeshData.uvs.end - encodedMeshData.uvs.start) / 4);
+                var float32Array2 = new Float32Array(buffer, encodedMeshData.uvs.start + offset, (encodedMeshData.uvs.end - encodedMeshData.uvs.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array2, vertexCount));
             }
             if (encodedMeshData.uv1) {
-                var float32Array3 = new Float32Array(buffer, encodedMeshData.uv1.start + offset + byteOffset, (encodedMeshData.uv1.end - encodedMeshData.uv1.start) / 4);
+                var float32Array3 = new Float32Array(buffer, encodedMeshData.uv1.start + offset, (encodedMeshData.uv1.end - encodedMeshData.uv1.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array3, vertexCount), 1);
             }
             if (encodedMeshData.uv2) {
-                var float32Array4 = new Float32Array(buffer, encodedMeshData.uv2.start + offset + byteOffset, (encodedMeshData.uv2.end - encodedMeshData.uv2.start) / 4);
+                var float32Array4 = new Float32Array(buffer, encodedMeshData.uv2.start + offset, (encodedMeshData.uv2.end - encodedMeshData.uv2.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array4, vertexCount), 2);
             }
             if (encodedMeshData.uv3) {
-                var float32Array5 = new Float32Array(buffer, encodedMeshData.uv3.start + offset + byteOffset, (encodedMeshData.uv3.end - encodedMeshData.uv3.start) / 4);
+                var float32Array5 = new Float32Array(buffer, encodedMeshData.uv3.start + offset, (encodedMeshData.uv3.end - encodedMeshData.uv3.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array5, vertexCount), 3);
             }
             if (encodedMeshData.uv4) {
-                var float32Array6 = new Float32Array(buffer, encodedMeshData.uv4.start + offset + byteOffset, (encodedMeshData.uv4.end - encodedMeshData.uv4.start) / 4);
+                var float32Array6 = new Float32Array(buffer, encodedMeshData.uv4.start + offset, (encodedMeshData.uv4.end - encodedMeshData.uv4.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array6, vertexCount), 4);
             }
             if (encodedMeshData.uv5) {
-                var float32Array7 = new Float32Array(buffer, encodedMeshData.uv5.start + offset + byteOffset, (encodedMeshData.uv5.end - encodedMeshData.uv5.start) / 4);
+                var float32Array7 = new Float32Array(buffer, encodedMeshData.uv5.start + offset, (encodedMeshData.uv5.end - encodedMeshData.uv5.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array7, vertexCount), 5);
             }
             if (encodedMeshData.uv6) {
-                var float32Array8 = new Float32Array(buffer, encodedMeshData.uv6.start + offset + byteOffset, (encodedMeshData.uv6.end - encodedMeshData.uv6.start) / 4);
+                var float32Array8 = new Float32Array(buffer, encodedMeshData.uv6.start + offset, (encodedMeshData.uv6.end - encodedMeshData.uv6.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array8, vertexCount), 6);
             }
             if (encodedMeshData.uv7) {
-                var float32Array9 = new Float32Array(buffer, encodedMeshData.uv7.start + offset + byteOffset, (encodedMeshData.uv7.end - encodedMeshData.uv7.start) / 4);
+                var float32Array9 = new Float32Array(buffer, encodedMeshData.uv7.start + offset, (encodedMeshData.uv7.end - encodedMeshData.uv7.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array9, vertexCount), 7);
             }
             if (encodedMeshData.colors) {
-                var float32Array10 = new Float32Array(buffer, encodedMeshData.colors.start + offset + byteOffset, (encodedMeshData.colors.end - encodedMeshData.colors.start) / 4);
+                var float32Array10 = new Float32Array(buffer, encodedMeshData.colors.start + offset, (encodedMeshData.colors.end - encodedMeshData.colors.start) / 4);
                 modelMesh.setColors(float32ArrayToVColor(float32Array10, vertexCount));
             }
             if (encodedMeshData.boneWeights) {
-                var float32Array11 = new Float32Array(buffer, encodedMeshData.boneWeights.start + offset + byteOffset, (encodedMeshData.boneWeights.end - encodedMeshData.boneWeights.start) / 4);
+                var float32Array11 = new Float32Array(buffer, encodedMeshData.boneWeights.start + offset, (encodedMeshData.boneWeights.end - encodedMeshData.boneWeights.start) / 4);
                 modelMesh.setBoneWeights(float32ArrayToVector4(float32Array11, vertexCount));
             }
             if (encodedMeshData.boneIndices) {
-                var float32Array12 = new Float32Array(buffer, encodedMeshData.boneIndices.start + offset + byteOffset, (encodedMeshData.boneIndices.end - encodedMeshData.boneIndices.start) / 4);
+                var float32Array12 = new Float32Array(buffer, encodedMeshData.boneIndices.start + offset, (encodedMeshData.boneIndices.end - encodedMeshData.boneIndices.start) / 4);
                 modelMesh.setBoneIndices(float32ArrayToVector4(float32Array12, vertexCount));
             }
             if (encodedMeshData.blendShapes) {
                 encodedMeshData.blendShapes.forEach(function(blendShapeData) {
                     var blendShape = new engineCore.BlendShape(blendShapeData.name);
                     blendShapeData.frames.forEach(function(frameData) {
-                        var positionArray = new Float32Array(buffer, frameData.deltaPosition.start + offset + byteOffset, (frameData.deltaPosition.end - frameData.deltaPosition.start) / 4);
+                        var positionArray = new Float32Array(buffer, frameData.deltaPosition.start + offset, (frameData.deltaPosition.end - frameData.deltaPosition.start) / 4);
                         var count = positionArray.length / 3;
                         var deltaPosition = float32ArrayToVector3(positionArray, count);
                         if (frameData.deltaNormals) {
-                            var normalsArray = new Float32Array(buffer, frameData.deltaNormals.start + offset + byteOffset, (frameData.deltaNormals.end - frameData.deltaNormals.start) / 4);
+                            var normalsArray = new Float32Array(buffer, frameData.deltaNormals.start + offset, (frameData.deltaNormals.end - frameData.deltaNormals.start) / 4);
                             float32ArrayToVector3(normalsArray, count);
                         }
                         if (frameData.deltaTangents) {
-                            var tangentsArray = new Float32Array(buffer, frameData.deltaTangents.start + offset + byteOffset, (frameData.deltaTangents.end - frameData.deltaTangents.start) / 4);
+                            var tangentsArray = new Float32Array(buffer, frameData.deltaTangents.start + offset, (frameData.deltaTangents.end - frameData.deltaTangents.start) / 4);
                             float32ArrayToVector4(tangentsArray, count);
                         }
                         blendShape.addFrame(frameData.weight, deltaPosition);
@@ -372,9 +371,9 @@ exports.MeshDecoder = /*#__PURE__*/ function() {
             if (encodedMeshData.indices) {
                 var indices = null;
                 if (encodedMeshData.indices.type === 0) {
-                    indices = new Uint16Array(buffer, encodedMeshData.indices.start + offset + byteOffset, (encodedMeshData.indices.end - encodedMeshData.indices.start) / 2);
+                    indices = new Uint16Array(buffer, encodedMeshData.indices.start + offset, (encodedMeshData.indices.end - encodedMeshData.indices.start) / 2);
                 } else {
-                    indices = new Uint32Array(buffer, encodedMeshData.indices.start + offset + byteOffset, (encodedMeshData.indices.end - encodedMeshData.indices.start) / 4);
+                    indices = new Uint32Array(buffer, encodedMeshData.indices.start + offset, (encodedMeshData.indices.end - encodedMeshData.indices.start) / 4);
                 }
                 modelMesh.setIndices(indices);
             }
@@ -1603,11 +1602,37 @@ var TextureWrapMode;
                 _this.get(9),
                 _this.get(2)
             ]).then(function() {
+                var glTFResource = _this.glTFResource;
+                if (glTFResource.skins || glTFResource.animations) {
+                    _this._createAnimator(_this, glTFResource.animations);
+                }
                 _this.resourceManager.addContentRestorer(_this.contentRestorer);
-                return _this.glTFResource;
+                return glTFResource;
             });
         });
     };
+    _proto._createAnimator = function _createAnimator(context, animations) {
+        var defaultSceneRoot = context.glTFResource.defaultSceneRoot;
+        var animator = defaultSceneRoot.addComponent(engineCore.Animator);
+        var animatorController = new engineCore.AnimatorController();
+        var layer = new engineCore.AnimatorControllerLayer("layer");
+        var animatorStateMachine = new engineCore.AnimatorStateMachine();
+        animatorController.addLayer(layer);
+        animator.animatorController = animatorController;
+        layer.stateMachine = animatorStateMachine;
+        if (animations) {
+            for(var i = 0; i < animations.length; i++){
+                var animationClip = animations[i];
+                var name = animationClip.name;
+                var uniqueName = animatorStateMachine.makeUniqueStateName(name);
+                if (uniqueName !== name) {
+                    console.warn("AnimatorState name is existed, name: " + name + " reset to " + uniqueName);
+                }
+                var animatorState = animatorStateMachine.addState(uniqueName);
+                animatorState.clip = animationClip;
+            }
+        }
+    };
     _proto._handleSubAsset = function _handleSubAsset(resource, type, index) {
         var _this = this;
         var glTFResourceKey = glTFResourceMap[type];
@@ -3533,6 +3558,7 @@ exports.GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
         var promises = new Array();
         // parse samplers
         for(var j = 0, m = samplers.length; j < m; j++)_loop(j);
+        promises.push(context.get(exports.GLTFParserType.Scene));
         return Promise.all(promises).then(function() {
             for(var j = 0, m = channels.length; j < m; j++){
                 var gltfChannel = channels[j];
@@ -3545,7 +3571,7 @@ exports.GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
                     entity = entity.parent;
                 }
                 // If the target node is in the default scene, relativePath will be empty
-                if (entity !== context.glTFResource.defaultSceneRoot) {
+                if (context.glTFResource.sceneRoots.indexOf(entity) === -1) {
                     continue;
                 }
                 var ComponentType = void 0;
@@ -4062,7 +4088,6 @@ exports.GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
     }
     var _proto = GLTFSceneParser.prototype;
     _proto.parse = function parse(context, index) {
-        var _this = this;
         var _context_glTF = context.glTF, scenes = _context_glTF.scenes, _context_glTF_scene = _context_glTF.scene, scene = _context_glTF_scene === void 0 ? 0 : _context_glTF_scene, glTFResource = context.glTFResource;
         var sceneInfo = scenes[index];
         var sceneExtensions = sceneInfo.extensions;
@@ -4092,18 +4117,6 @@ exports.GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
         }
         return Promise.all(promises).then(function() {
             GLTFParser.executeExtensionsAdditiveAndParse(sceneExtensions, context, sceneRoot, sceneInfo);
-            if (isDefaultScene) {
-                return Promise.all([
-                    context.get(exports.GLTFParserType.Skin),
-                    context.get(exports.GLTFParserType.Animation)
-                ]).then(function(param) {
-                    var skins = param[0], animations = param[1];
-                    if (skins || animations) {
-                        _this._createAnimator(context, animations);
-                    }
-                    return sceneRoot;
-                });
-            }
             return sceneRoot;
         });
     };
@@ -4215,28 +4228,6 @@ exports.GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
         for(var i = 0; i < glTFMeshPrimitives.length; i++)_loop(i);
         return Promise.all(promises);
     };
-    _proto._createAnimator = function _createAnimator(context, animations) {
-        var defaultSceneRoot = context.glTFResource.defaultSceneRoot;
-        var animator = defaultSceneRoot.addComponent(engineCore.Animator);
-        var animatorController = new engineCore.AnimatorController();
-        var layer = new engineCore.AnimatorControllerLayer("layer");
-        var animatorStateMachine = new engineCore.AnimatorStateMachine();
-        animatorController.addLayer(layer);
-        animator.animatorController = animatorController;
-        layer.stateMachine = animatorStateMachine;
-        if (animations) {
-            for(var i = 0; i < animations.length; i++){
-                var animationClip = animations[i];
-                var name = animationClip.name;
-                var uniqueName = animatorStateMachine.makeUniqueStateName(name);
-                if (uniqueName !== name) {
-                    console.warn("AnimatorState name is existed, name: " + name + " reset to " + uniqueName);
-                }
-                var animatorState = animatorStateMachine.addState(uniqueName);
-                animatorState.clip = animationClip;
-            }
-        }
-    };
     _proto._computeLocalBounds = function _computeLocalBounds(skinnedMeshRenderer, mesh, bones, rootBone, inverseBindMatrices) {
         var rootBoneIndex = bones.indexOf(rootBone);
         if (rootBoneIndex !== -1) {