@galacean/engine-core 1.3.10 → 1.3.11

package/dist/main.js

@@ -6611,13 +6611,17 @@ SlicedSpriteAssembler = __decorate([
  */ var DisorderedArray = /*#__PURE__*/ function() {
     function DisorderedArray(count) {
         if (count === void 0) count = 0;
-        this.length = 0;
-        this._isLooping = false;
+        /** The length of the array. */ this.length = 0;
+        this._loopCounter = 0 // Ignore nested loops, use counter to solve the problem
+        ;
         this._blankCount = 0;
         this._elements = new Array(count);
     }
     var _proto = DisorderedArray.prototype;
-    _proto.add = function add(element) {
+    /**
+   * Add an element to disordered array.
+   * @param element - The element to be added
+   */ _proto.add = function add(element) {
         if (this.length === this._elements.length) {
             this._elements.push(element);
         } else {
@@ -6625,18 +6629,29 @@ SlicedSpriteAssembler = __decorate([
         }
         this.length++;
     };
-    _proto.delete = function _delete(element) {
+    /**
+   * Delete the specified element.
+   * @param element - The element to be deleted
+   */ _proto.delete = function _delete(element) {
         // @todo: It can be optimized for custom binary search and other algorithms, currently this._elements>=this.length wastes performance.
         var index = this._elements.indexOf(element);
         this.deleteByIndex(index);
     };
-    _proto.set = function set(index, element) {
+    /**
+   * Set the element at the specified index.
+   * @param index - The index of the element to be set
+   * @param element - The element to be set
+   */ _proto.set = function set(index, element) {
         if (index >= this.length) {
             throw "Index is out of range.";
         }
         this._elements[index] = element;
     };
-    _proto.get = function get(index) {
+    /**
+   * Get the element at the specified index.
+   * @param index - The index of the element to be get
+   * @returns The element at the specified index
+   */ _proto.get = function get(index) {
         if (index >= this.length) {
             throw "Index is out of range.";
         }
@@ -6649,7 +6664,7 @@ SlicedSpriteAssembler = __decorate([
    */ _proto.deleteByIndex = function deleteByIndex(index) {
         var elements = this._elements;
         var end;
-        if (this._isLooping) {
+        if (this._loopCounter > 0) {
             this._elements[index] = null;
             this._blankCount++;
         } else {
@@ -6663,41 +6678,57 @@ SlicedSpriteAssembler = __decorate([
         }
         return end;
     };
-    _proto.forEach = function forEach(callbackFn, swapFn) {
+    /**
+   * Loop through all elements.
+   * @param callbackFn - The callback function
+   * @param swapFn - The swap function can process the element after the callback function, it will be called after end looping(`isLopping` = true)
+   */ _proto.forEach = function forEach(callbackFn, swapFn) {
         this._startLoop();
         var elements = this._elements;
         for(var i = 0, n = this.length; i < n; i++){
             var element = elements[i];
-            element && callbackFn(element);
+            element && callbackFn(element, i);
         }
         this._endLoop(swapFn);
     };
-    _proto.forEachAndClean = function forEachAndClean(callbackFn, swapFn) {
+    /**
+   * Loop through all elements and clean up the blank elements.
+   * @param callbackFn - The callback function
+   * @param swapFn - The swap function can process the element after the callback function,  it will be called after end looping(`isLopping` = true)
+   */ _proto.forEachAndClean = function forEachAndClean(callbackFn, swapFn) {
         this._startLoop();
         var preEnd = this.length;
         var elements = this._elements;
         for(var i = 0, n = preEnd; i < n; i++){
             var element = elements[i];
-            element && callbackFn(element);
+            element && callbackFn(element, i);
         }
         this._endLoopAndClean(preEnd, elements, swapFn);
     };
-    _proto.sort = function sort(compareFn) {
+    /**
+   * Sort the array.
+   * @param compareFn - The comparison function
+   */ _proto.sort = function sort(compareFn) {
         Utils._quickSort(this._elements, 0, this.length, compareFn);
     };
-    _proto.garbageCollection = function garbageCollection() {
+    /**
+   * Garbage collection, clean up all cached elements.
+   */ _proto.garbageCollection = function garbageCollection() {
         this._elements.length = this.length;
     };
     _proto._startLoop = function _startLoop() {
-        this._isLooping = true;
+        ++this._loopCounter;
     };
     _proto._endLoop = function _endLoop(swapFn) {
-        this._isLooping = false;
+        if (--this._loopCounter !== 0) {
+            return;
+        }
         if (this._blankCount) {
             var from = 0;
             var to = this.length - 1;
             var elements = this._elements;
             partition: do {
+                var _swapFn;
                 while(elements[from])if (++from >= to) {
                     break partition;
                 }
@@ -6705,7 +6736,7 @@ SlicedSpriteAssembler = __decorate([
                     break partition;
                 }
                 var swapElement = elements[to];
-                swapFn(swapElement, from);
+                (_swapFn = swapFn) == null ? void 0 : _swapFn(swapElement, from);
                 elements[from++] = swapElement;
                 elements[to--] = null;
             }while (from < to);
@@ -6714,18 +6745,31 @@ SlicedSpriteAssembler = __decorate([
         }
     };
     _proto._endLoopAndClean = function _endLoopAndClean(preEnd, elements, swapFn) {
+        if (--this._loopCounter !== 0) {
+            return;
+        }
         var index = 0;
         for(var i = preEnd, n = this.length; i < n; i++){
+            var _swapFn;
             var element = elements[i];
             if (!element) continue;
             elements[index] = element;
-            swapFn(element, index);
+            (_swapFn = swapFn) == null ? void 0 : _swapFn(element, index);
             index++;
         }
-        this._isLooping = false;
         this.length = index;
         this._blankCount = 0;
     };
+    _create_class(DisorderedArray, [
+        {
+            key: "isLopping",
+            get: /**
+   * Get whether the array is in the loop.
+   */ function get() {
+                return this._loopCounter > 0;
+            }
+        }
+    ]);
     return DisorderedArray;
 }();
 
@@ -34464,6 +34508,7 @@ exports.CubeProbe = CubeProbe;
 exports.CurveKey = CurveKey;
 exports.DepthState = DepthState;
 exports.DirectLight = DirectLight;
+exports.DisorderedArray = DisorderedArray;
 exports.DynamicCollider = DynamicCollider;
 exports.EmissionModule = EmissionModule;
 exports.Engine = Engine;