@galacean/engine 0.0.0-experimental-2.0-game.11 → 0.0.0-experimental-2.0-game.13

package/dist/browser.js

@@ -10787,8 +10787,13 @@
             rotation._onValueChanged = target._onRotationChanged;
             // @ts-ignore
             scale._onValueChanged = target._onScaleChanged;
-            // When cloning, other components may obtain properties such as `rotationQuaternion` in the constructor, local related dirty flags need to be corrected
+            // When cloning, other components may obtain properties such as `rotationQuaternion` in the constructor, local related dirty flags need to be corrected.
+            // Earlier in this Entity's construction other components (e.g. DynamicCollider) may have queried
+            // `worldPosition`, which clears the WorldPosition / WorldMatrix dirty flags as a side effect of caching
+            // the computed value. After this _cloneTo writes new local values, those world-derived caches are stale,
+            // so re-dirty them and notify listeners (Collider._updateFlag etc.) so subsequent reads recompute correctly.
             target._setDirtyFlagTrue(2 | 64);
+            target._worldAssociatedChange(444);
         };
         _proto._onLocalMatrixChanging = function _onLocalMatrixChanging() {
             this._setDirtyFlagFalse(64);
@@ -12739,7 +12744,13 @@
     };
     ShaderFactory._has300OutInFragReg = /\bout\s+(?:\w+\s+)?vec4\s+\w+\s*;/;
     ShaderFactory._precisionStr = "\n#ifdef GL_FRAGMENT_PRECISION_HIGH\n  precision highp float;\n  precision highp int;\n#else\n  precision mediump float;\n  precision mediump int;\n#endif\n";
-    ShaderFactory._derivedDefines = "#define renderer_MVMat (camera_ViewMat * renderer_ModelMat)\n#define renderer_MVPMat (camera_VPMat * renderer_ModelMat)\n#define renderer_NormalMat mat4(transpose(inverse(mat3(renderer_ModelMat))))";
+    // Derived built-ins re-exposed on top of `renderer_ModelMat`.
+    // `renderer_NormalMat` uses the cofactor (cross-product) form, which algebraically equals
+    // `det(M) · transpose(inverse(M))`. After `normalize()` it's directionally identical to the
+    // classic `transpose(inverse(M))`, but stays NaN-free when `M` is singular (e.g. any scale
+    // axis is 0 — common in animations that pop / hide via scale). `sign(det)` (`s` below)
+    // keeps mirrored matrices facing the right way
+    ShaderFactory._derivedDefines = "mat3 _normalMatFromModel(mat3 m) {\n    vec3 c0 = cross(m[1], m[2]);\n    vec3 c1 = cross(m[2], m[0]);\n    vec3 c2 = cross(m[0], m[1]);\n    float s = (dot(m[0], c0) < 0.0) ? -1.0 : 1.0;\n    return mat3(c0 * s, c1 * s, c2 * s);\n}\n#define renderer_MVMat (camera_ViewMat * renderer_ModelMat)\n#define renderer_MVPMat (camera_VPMat * renderer_ModelMat)\n#define renderer_NormalMat mat4(_normalMatFromModel(mat3(renderer_ModelMat)))";
     // Built-in renderer uniforms. value=true means derived (remove but not added to UBO)
     ShaderFactory._builtinRendererUniforms = {
         renderer_ModelMat: false,
@@ -23975,7 +23986,7 @@
         /** Scene. */ AssetType["Scene"] = "Scene";
         /** Font. */ AssetType["Font"] = "Font";
         /** Source Font, include ttf, otf and woff. */ AssetType["SourceFont"] = "SourceFont";
-        /** AudioClip, include ogg, wav and mp3. */ AssetType["Audio"] = "Audio";
+        /** AudioClip, include ogg, wav, mp3, m4a, aac and flac. */ AssetType["Audio"] = "Audio";
         /** Project asset. */ AssetType["Project"] = "project";
         /** PhysicsMaterial. */ AssetType["PhysicsMaterial"] = "PhysicsMaterial";
         /** RenderTarget. */ AssetType["RenderTarget"] = "RenderTarget";
@@ -25433,17 +25444,23 @@
         /**
        * @internal
        */ _proto._onUpdate = function _onUpdate() {
+            var shapes = this._shapes;
             if (this._updateFlag.flag) {
                 var transform = this.entity.transform;
-                this._nativeCollider.setWorldTransform(transform.worldPosition, transform.worldRotationQuaternion);
+                this._syncEntityTransformToNative(transform.worldPosition, transform.worldRotationQuaternion);
                 var worldScale = transform.lossyWorldScale;
-                var shapes = this._shapes;
                 for(var i = 0, n = shapes.length; i < n; i++){
                     var _shapes_i__nativeShape;
                     (_shapes_i__nativeShape = shapes[i]._nativeShape) == null ? void 0 : _shapes_i__nativeShape.setWorldScale(worldScale);
                 }
                 this._updateFlag.flag = false;
             }
+            // Drive per-shape physics update (e.g. MeshColliderShape retries pending
+            // native shape creation when mesh data becomes accessible asynchronously).
+            // No-op for shape types that don't override `_onPhysicsUpdate`.
+            for(var i1 = 0, n1 = shapes.length; i1 < n1; i1++){
+                shapes[i1]._onPhysicsUpdate();
+            }
         };
         /**
        * @internal
@@ -25475,6 +25492,28 @@
                 this._addNativeShape(this.shapes[i]);
             }
             this._setCollisionLayer();
+            // Teleport native actor to entity's current world pose.
+            // The native actor was created in constructor() with the entity's then-current
+            // worldPosition/Rotation. On clone, the entity's transform fields are deep-cloned
+            // AFTER the Component (and its native actor) are constructed, so the native actor's
+            // pose lags behind the cloned entity transform until this sync.
+            var transform = this.entity.transform;
+            this._teleportToEntityTransform(transform.worldPosition, transform.worldRotationQuaternion);
+        };
+        /**
+       * Teleport native actor to a world pose (instant, no implied velocity).
+       * Used during initialization paths (clone) where the native actor must be re-aligned
+       * with the entity transform after construction-time pose was based on stale defaults.
+       */ _proto._teleportToEntityTransform = function _teleportToEntityTransform(worldPosition, worldRotation) {
+            this._nativeCollider.setWorldTransform(worldPosition, worldRotation);
+        };
+        /**
+       * Sync entity world transform to native actor for per-frame updates.
+       * Default semantics: teleport (setGlobalPose). Subclasses override to express
+       * physics-aware movement (e.g. DynamicCollider routes kinematic actors through
+       * setKinematicTarget to generate contact events on swept motion).
+       */ _proto._syncEntityTransformToNative = function _syncEntityTransformToNative(worldPosition, worldRotation) {
+            this._nativeCollider.setWorldTransform(worldPosition, worldRotation);
         };
         /**
        * @internal
@@ -25632,6 +25671,9 @@
             this._nativeCollider.setUpDirection(this._upDirection);
             this._nativeCollider.setSlopeLimit(this._slopeLimit);
         };
+        _proto._teleportToEntityTransform = function _teleportToEntityTransform(worldPosition, _worldRotation) {
+            this._nativeCollider.setWorldPosition(worldPosition);
+        };
         _proto._syncWorldPositionFromPhysicalSpace = function _syncWorldPositionFromPhysicalSpace() {
             this._nativeCollider.getWorldPosition(this.entity.transform.worldPosition);
         };
@@ -25731,7 +25773,7 @@
             this._staticFriction = 0.6;
             this._bounceCombine = PhysicsMaterialCombineMode.Average;
             this._frictionCombine = PhysicsMaterialCombineMode.Average;
-            this._nativeMaterial = Engine._nativePhysics.createPhysicsMaterial(this._staticFriction, this._dynamicFriction, this._bounciness, this._bounceCombine, this._frictionCombine);
+            this._nativeMaterial = Engine._nativePhysics.createPhysicsMaterial(this._staticFriction, this._dynamicFriction, this._bounciness, this._frictionCombine, this._bounceCombine);
         }
         var _proto = PhysicsMaterial.prototype;
         /**
@@ -25740,6 +25782,21 @@
             !this._destroyed && this._nativeMaterial.destroy();
             this._destroyed = true;
         };
+        /**
+       * @internal
+       */ _proto._cloneTo = function _cloneTo(target) {
+            target._syncNative();
+        };
+        /**
+       * @internal
+       */ _proto._syncNative = function _syncNative() {
+            var nativeMaterial = this._nativeMaterial;
+            nativeMaterial.setStaticFriction(this._staticFriction);
+            nativeMaterial.setDynamicFriction(this._dynamicFriction);
+            nativeMaterial.setBounciness(this._bounciness);
+            nativeMaterial.setFrictionCombine(this._frictionCombine);
+            nativeMaterial.setBounceCombine(this._bounceCombine);
+        };
         _create_class$2(PhysicsMaterial, [
             {
                 key: "bounciness",
@@ -25814,6 +25871,9 @@
         ]);
         return PhysicsMaterial;
     }();
+    __decorate$1([
+        ignoreClone
+    ], PhysicsMaterial.prototype, "_nativeMaterial", void 0);
     /**
      * Abstract class for collider shapes.
      */ var ColliderShape = /*#__PURE__*/ function() {
@@ -25865,6 +25925,16 @@
         };
         /**
        * @internal
+       *
+       * Called once per physics update tick by `Collider._onUpdate`. Base no-op.
+       *
+       * Subclasses can override for frame-driven maintenance. Currently used by
+       * `MeshColliderShape` to retry native shape creation when mesh data becomes
+       * accessible later or PhysX cooking previously failed due to transient state
+       * (async resource loading, cook pipeline warmup, etc.).
+       */ _proto._onPhysicsUpdate = function _onPhysicsUpdate() {};
+        /**
+       * @internal
        */ _proto._destroy = function _destroy() {
             if (this._nativeShape) {
                 this._nativeShape.destroy();
@@ -26013,7 +26083,11 @@
         _inherits$2(MeshColliderShape, ColliderShape);
         function MeshColliderShape() {
             var _this;
-            _this = ColliderShape.apply(this, arguments) || this, _this._mesh = null, _this._isConvex = false, _this._positions = null, _this._indices = null, _this._cookingFlags = MeshColliderShapeCookingFlag.Cleaning | MeshColliderShapeCookingFlag.VertexWelding, _this._isShapeAttached = false;
+            _this = ColliderShape.apply(this, arguments) || this, _this._mesh = null, _this._isConvex = false, _this._positions = null, _this._indices = null, _this._cookingFlags = MeshColliderShapeCookingFlag.Cleaning | MeshColliderShapeCookingFlag.VertexWelding, _this._isShapeAttached = false, /**
+       * `true` if a native shape creation was attempted but failed (mesh data not yet
+       * accessible, PhysX cooking transient failure, etc.). The `_onPhysicsUpdate` hook
+       * will keep retrying every frame until creation succeeds.
+       */ _this._pendingNativeShapeCreation = false;
             return _this;
         }
         var _proto = MeshColliderShape.prototype;
@@ -26097,9 +26171,12 @@
             }
             var nativeShape = Engine._nativePhysics.createMeshColliderShape(this._id, this._positions, this._indices, this._isConvex, this._material._nativeMaterial, this._cookingFlags);
             if (!nativeShape) {
+                // Cook failed — `_onPhysicsUpdate` will retry next frame
+                this._pendingNativeShapeCreation = true;
                 return;
             }
             this._nativeShape = nativeShape;
+            this._pendingNativeShapeCreation = false;
             // Sync base class properties (position, rotation, contactOffset, isTrigger, material)
             ColliderShape.prototype._syncNative.call(this);
             // If already attached to a collider, add the newly created native shape to it
@@ -26108,6 +26185,36 @@
                 this._attachToCollider();
             }
         };
+        /**
+       * @internal
+       * Retry hook: keep attempting `_createNativeShape` until it succeeds.
+       *
+       * Triggered every physics update tick by `Collider._onUpdate`. Handles the case
+       * where `_cookMesh` fails on first attempt due to PhysX cooking pipeline timing
+       * (the mesh data was extracted successfully at `set mesh` time, but the native
+       * cook call returned null). No-op once a valid native shape exists.
+       *
+       * We DO NOT re-call `_extractMeshData` here — once `set mesh` finished, either:
+       *   - extraction succeeded → `_positions` is populated and we reuse it
+       *   - extraction failed → `_clearMeshData` cleared `_positions`, and `mesh.accessible`
+       *     won't recover (GPU upload is one-way), so re-extracting would fail again
+       */ _proto._onPhysicsUpdate = function _onPhysicsUpdate() {
+            if (!this._pendingNativeShapeCreation || !this._mesh || !this._positions) return;
+            this._createNativeShape();
+        };
+        /**
+       * @internal
+       * After CloneManager deep-copies `_positions` / `_indices` / `_mesh` and remaps `_collider`,
+       * the cloned shape still has no native PhysX shape because `_nativeShape` is `@ignoreClone`.
+       * Cook a fresh native shape now using the already-cloned vertex/index buffers; on transient
+       * cook failure `_createNativeShape` sets `_pendingNativeShapeCreation = true` and
+       * `_onPhysicsUpdate` will retry next tick.
+       */ _proto._cloneTo = function _cloneTo(target) {
+            ColliderShape.prototype._cloneTo.call(this, target);
+            if (target._positions) {
+                target._createNativeShape();
+            }
+        };
         _create_class$2(MeshColliderShape, [
             {
                 key: "cookingFlags",
@@ -26167,15 +26274,25 @@
                         (_this__mesh = this._mesh) == null ? void 0 : _this__mesh._addReferCount(-1);
                         value == null ? void 0 : value._addReferCount(1);
                         this._mesh = value;
-                        if (value && this._extractMeshData(value)) {
-                            if (this._nativeShape) {
-                                this._updateNativeShapeData();
+                        if (value) {
+                            if (this._extractMeshData(value)) {
+                                if (this._nativeShape) {
+                                    this._updateNativeShapeData();
+                                } else {
+                                    this._createNativeShape();
+                                }
+                                // _createNativeShape can fail silently (cookMesh transient failure); mark pending if so
+                                this._pendingNativeShapeCreation = !this._nativeShape;
                             } else {
-                                this._createNativeShape();
+                                // Mesh not yet accessible — keep pending so `_onPhysicsUpdate` retries later
+                                this._destroyNativeShape();
+                                this._clearMeshData();
+                                this._pendingNativeShapeCreation = true;
                             }
                         } else {
                             this._destroyNativeShape();
                             this._clearMeshData();
+                            this._pendingNativeShapeCreation = false;
                         }
                     }
                 }
@@ -26219,6 +26336,27 @@
        */ _proto.applyTorque = function applyTorque(torque) {
             this._phasedActiveInScene && this._nativeCollider.addTorque(torque);
         };
+        /**
+       * Apply a force to the DynamicCollider at a given position in world space.
+       * The force generates both linear acceleration through the center of mass and angular
+       * acceleration about it (torque = (position - centerOfMass) × force).
+       * @param force - The force to apply, in world space
+       * @param position - The position where the force is applied, in world space
+       */ _proto.applyForceAtPosition = function applyForceAtPosition(force, position) {
+            if (!this._phasedActiveInScene) return;
+            var nativeCollider = this._nativeCollider;
+            var localCoM = DynamicCollider._tempVector3;
+            nativeCollider.getCenterOfMass(localCoM);
+            var transform = this.entity.transform;
+            var worldCoM = DynamicCollider._tempVector3_1;
+            Vector3.transformByQuat(localCoM, transform.worldRotationQuaternion, worldCoM);
+            worldCoM.add(transform.worldPosition);
+            var torque = DynamicCollider._tempVector3_2;
+            Vector3.subtract(position, worldCoM, torque);
+            Vector3.cross(torque, force, torque);
+            nativeCollider.addForce(force);
+            nativeCollider.addTorque(torque);
+        };
         _proto.move = function move(positionOrRotation, rotation) {
             if (!this._isKinematic) {
                 console.warn("DynamicCollider: move() is only supported when isKinematic is true.");
@@ -26252,6 +26390,31 @@
             Collider.prototype.addShape.call(this, shape);
         };
         /**
+       * Route per-frame entity → native transform sync to the correct physics API based
+       * on kinematic state.
+       *
+       * PhysX 4.x docs (PxRigidDynamic):
+       *   "If you intend to move a kinematic actor with [setGlobalPose] and want
+       *    collision detection, use setKinematicTarget() instead."
+       *
+       * setGlobalPose is a teleport: PhysX skips contact detection between the old
+       * and new pose, so two kinematic actors moved onto each other via entity.transform
+       * mutation would NOT produce onCollisionEnter / onCollisionStay events even when
+       * scene.kineKineFilteringMode = eKEEP. Routing the per-frame sync through
+       * IDynamicCollider.move() (which the PhysX backend implements as
+       * setKinematicTarget) tells PhysX the actor is animating to the target during the
+       * next simulate(), enabling sweep contact detection for kine-kine and kine-dynamic
+       * pairs alike.
+       *
+       * @internal
+       */ _proto._syncEntityTransformToNative = function _syncEntityTransformToNative(worldPosition, worldRotation) {
+            if (this._isKinematic) {
+                this._nativeCollider.move(worldPosition, worldRotation);
+            } else {
+                Collider.prototype._syncEntityTransformToNative.call(this, worldPosition, worldRotation);
+            }
+        };
+        /**
        * @internal
        */ _proto._onLateUpdate = function _onLateUpdate() {
             var transform = this.entity.transform;
@@ -26625,6 +26788,8 @@
         return DynamicCollider;
     }(exports.Collider);
     DynamicCollider._tempVector3 = new Vector3();
+    DynamicCollider._tempVector3_1 = new Vector3();
+    DynamicCollider._tempVector3_2 = new Vector3();
     DynamicCollider._tempQuat = new Quaternion();
     __decorate$1([
         ignoreClone
@@ -26701,8 +26866,7 @@
        * You need to obtain the actual number of contact points from the function's return value.
        */ _proto.getContacts = function getContacts(outContacts) {
             var nativeCollision = this._nativeCollision;
-            var smallerShapeId = Math.min(nativeCollision.shape0Id, nativeCollision.shape1Id);
-            var factor = this.shape.id === smallerShapeId ? 1 : -1;
+            var factor = this.shape.id === nativeCollision.shape1Id ? 1 : -1;
             var nativeContactPoints = nativeCollision.getContacts();
             var length = nativeContactPoints.size();
             for(var i = 0; i < length; i++){
@@ -38182,8 +38346,8 @@
             if (this._tryCrossFadeInterrupt(layerData, transitionDuration, destState, deltaTime, aniUpdate)) {
                 return;
             }
-            var srcPlaySpeed = srcState.speed * speed;
-            var dstPlaySpeed = destState.speed * speed;
+            var srcPlaySpeed = srcPlayData.speed * speed;
+            var dstPlaySpeed = destPlayData.speed * speed;
             var dstPlayDeltaTime = dstPlaySpeed * deltaTime;
             srcPlayData && srcPlayData.updateOrientation(srcPlaySpeed * deltaTime);
             destPlayData && destPlayData.updateOrientation(dstPlayDeltaTime);
@@ -53700,32 +53864,10 @@
             if (rootBoneIndex !== -1) {
                 BoundingBox.transform(mesh.bounds, inverseBindMatrices[rootBoneIndex], skinnedMeshRenderer.localBounds);
             } else {
-                // Root bone is not in joints list, we can only compute approximate inverse bind matrix
-                // Average all root bone's children inverse bind matrix
-                var approximateBindMatrix = new Matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
-                var subRootBoneCount = this._computeApproximateBindMatrix(bones, inverseBindMatrices, rootBone, approximateBindMatrix);
-                if (subRootBoneCount !== 0) {
-                    Matrix.multiplyScalar(approximateBindMatrix, 1.0 / subRootBoneCount, approximateBindMatrix);
-                    BoundingBox.transform(mesh.bounds, approximateBindMatrix, skinnedMeshRenderer.localBounds);
-                } else {
-                    skinnedMeshRenderer.localBounds.copyFrom(mesh.bounds);
-                }
-            }
-        };
-        _proto._computeApproximateBindMatrix = function _computeApproximateBindMatrix(jointEntities, inverseBindMatrices, rootEntity, approximateBindMatrix) {
-            var subRootBoneCount = 0;
-            var children = rootEntity.children;
-            for(var i = 0, n = children.length; i < n; i++){
-                var rootChild = children[i];
-                var index = jointEntities.indexOf(rootChild);
-                if (index !== -1) {
-                    Matrix.add(approximateBindMatrix, inverseBindMatrices[index], approximateBindMatrix);
-                    subRootBoneCount++;
-                } else {
-                    subRootBoneCount += this._computeApproximateBindMatrix(jointEntities, inverseBindMatrices, rootChild, approximateBindMatrix);
-                }
+                var inverseRootBoneWorld = new Matrix();
+                Matrix.invert(rootBone.transform.worldMatrix, inverseRootBoneWorld);
+                BoundingBox.transform(mesh.bounds, inverseRootBoneWorld, skinnedMeshRenderer.localBounds);
             }
-            return subRootBoneCount;
         };
         return GLTFSceneParser;
     }(GLTFParser);
@@ -53767,8 +53909,7 @@
                     var rootBone = entities[skeleton];
                     skin.rootBone = rootBone;
                 } else {
-                    var _this__findSceneRootBone;
-                    var rootBone1 = (_this__findSceneRootBone = _this._findSceneRootBone(context, joints, entities)) != null ? _this__findSceneRootBone : _this._findSkeletonRootBone(joints, entities);
+                    var rootBone1 = _this._findSkinRootBoneByLCA(index, joints, entities, glTF.nodes);
                     if (rootBone1) {
                         skin.rootBone = rootBone1;
                     } else {
@@ -53779,46 +53920,20 @@
             });
             return AssetPromise.resolve(skinPromise);
         };
-        _proto._findSceneRootBone = function _findSceneRootBone(context, joints, entities) {
-            var glTF = context.glTF, glTFResource = context.glTFResource;
-            var scenes = glTF.scenes;
-            var sceneRoots = glTFResource._sceneRoots;
-            if (!(scenes == null ? void 0 : scenes.length) || !(sceneRoots == null ? void 0 : sceneRoots.length)) {
-                return null;
-            }
-            for(var i = 0, n = scenes.length; i < n; i++){
-                var _scenes_i_nodes;
-                var sceneNodes = (_scenes_i_nodes = scenes[i].nodes) != null ? _scenes_i_nodes : [];
-                if (sceneNodes.length <= 1) {
-                    continue;
-                }
-                var sceneRoot = sceneRoots[i];
-                if (!sceneRoot) {
-                    continue;
-                }
-                var sceneRootChildren = new Set(sceneNodes.map(function(nodeIndex) {
-                    return entities[nodeIndex];
-                }));
-                var allJointsUnderSceneRoot = true;
-                for(var j = 0, m = joints.length; j < m; j++){
-                    var entity = entities[joints[j]];
-                    while(entity == null ? void 0 : entity.parent){
-                        entity = entity.parent;
-                    }
-                    if (!sceneRootChildren.has(entity)) {
-                        allJointsUnderSceneRoot = false;
-                        break;
-                    }
-                }
-                if (allJointsUnderSceneRoot) {
-                    return sceneRoot;
+        _proto._findSkinRootBoneByLCA = function _findSkinRootBoneByLCA(skinIndex, joints, entities, nodes) {
+            if (nodes === void 0) nodes = [];
+            var nodeIndices = joints.slice();
+            for(var i = 0, n = nodes.length; i < n; i++){
+                var _nodes_i;
+                if (((_nodes_i = nodes[i]) == null ? void 0 : _nodes_i.skin) === skinIndex) {
+                    nodeIndices.push(i);
                 }
             }
-            return null;
+            return this._findRootBoneByLCA(nodeIndices, entities);
         };
-        _proto._findSkeletonRootBone = function _findSkeletonRootBone(joints, entities) {
-            var paths = {};
-            for(var _iterator = _create_for_of_iterator_helper_loose(joints), _step; !(_step = _iterator()).done;){
+        _proto._findRootBoneByLCA = function _findRootBoneByLCA(nodeIndices, entities) {
+            var paths = [];
+            for(var _iterator = _create_for_of_iterator_helper_loose(nodeIndices), _step; !(_step = _iterator()).done;){
                 var index = _step.value;
                 var path = new Array();
                 var entity = entities[index];
@@ -53826,17 +53941,22 @@
                     path.unshift(entity);
                     entity = entity.parent;
                 }
-                paths[index] = path;
+                if (path.length) {
+                    paths.push(path);
+                }
+            }
+            if (!paths.length) {
+                return null;
             }
             var rootNode = null;
             for(var i = 0;; i++){
-                var path1 = paths[joints[0]];
+                var path1 = paths[0];
                 if (i >= path1.length) {
                     return rootNode;
                 }
                 var entity1 = path1[i];
-                for(var j = 1, m = joints.length; j < m; j++){
-                    path1 = paths[joints[j]];
+                for(var j = 1, m = paths.length; j < m; j++){
+                    path1 = paths[j];
                     if (i >= path1.length || entity1 !== path1[i]) {
                         return rootNode;
                     }
@@ -55381,7 +55501,10 @@
             "mp3",
             "ogg",
             "wav",
-            "audio"
+            "audio",
+            "m4a",
+            "aac",
+            "flac"
         ])
     ], AudioLoader);
     var ShaderChunkLoader = /*#__PURE__*/ function(Loader) {
@@ -56171,7 +56294,7 @@
     ], EXT_texture_webp);
 
     //@ts-ignore
-    var version = "0.0.0-experimental-2.0-game.11";
+    var version = "0.0.0-experimental-2.0-game.13";
     console.log("Galacean Engine Version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);