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

package/dist/browser.js

@@ -37435,116 +37435,116 @@
             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 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;
                 }
             }
         ]);
@@ -37605,75 +37605,74 @@
                 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 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);
@@ -37684,9 +37683,9 @@
                 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);
                 }
@@ -38879,11 +38878,37 @@
                     _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(Animator);
+            var animatorController = new AnimatorController();
+            var layer = new AnimatorControllerLayer("layer");
+            var animatorStateMachine = new 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];
@@ -40793,6 +40818,7 @@
             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];
@@ -40805,7 +40831,7 @@
                         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;
@@ -41316,7 +41342,6 @@
         _inherits(GLTFSceneParser, 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;
@@ -41346,18 +41371,6 @@
             }
             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;
             });
         };
@@ -41469,28 +41482,6 @@
             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(Animator);
-            var animatorController = new AnimatorController();
-            var layer = new AnimatorControllerLayer("layer");
-            var animatorStateMachine = new 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) {
@@ -43354,7 +43345,7 @@
     ], GALACEAN_animation_event);
 
     //@ts-ignore
-    var version = "1.1.0-beta.16";
+    var version = "1.1.0-beta.17";
     console.log("Galacean engine version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);