初始化

engine/cocos2d/renderer/memop/circular-pool.js

@@ -0,0 +1,17 @@
+export default class CircularPool {
+  constructor(fn, size) {
+    this._cursor = 0;
+    this._data = new Array(size);
+
+    for (let i = 0; i < size; ++i) {
+      this._data[i] = fn();
+    }
+  }
+
+  request() {
+    let item = this._data[this._cursor];
+    this._cursor = (this._cursor + 1) % this._data.length;
+
+    return item;
+  }
+}

engine/cocos2d/renderer/memop/fixed-array.js

@@ -0,0 +1,73 @@
+import sort from './timsort';
+
+export default class FixedArray {
+  constructor(size) {
+    this._count = 0;
+    this._data = new Array(size);
+  }
+
+  _resize(size) {
+    if (size > this._data.length) {
+      for (let i = this._data.length; i < size; ++i) {
+        this._data[i] = undefined;
+      }
+    }
+  }
+
+  get length() {
+    return this._count;
+  }
+
+  get data() {
+    return this._data;
+  }
+
+  reset() {
+    for (let i = 0; i < this._count; ++i) {
+      this._data[i] = undefined;
+    }
+
+    this._count = 0;
+  }
+
+  push(val) {
+    if (this._count >= this._data.length) {
+      this._resize(this._data.length * 2);
+    }
+
+    this._data[this._count] = val;
+    ++this._count;
+  }
+
+  pop() {
+    --this._count;
+
+    if (this._count < 0) {
+      this._count = 0;
+    }
+
+    let ret = this._data[this._count];
+    this._data[this._count] = undefined;
+
+    return ret;
+  }
+
+  fastRemove(idx) {
+    if (idx >= this._count || idx < 0) {
+      return;
+    }
+
+    let last = this._count - 1;
+    this._data[idx] = this._data[last];
+    this._data[last] = undefined;
+    this._count -= 1;
+  }
+
+  indexOf(val) {
+    return this._data.indexOf(val);
+  }
+
+  sort(cmp) {
+    return sort(this._data, 0, this._count, cmp);
+  }
+}

engine/cocos2d/renderer/memop/index.js

@@ -0,0 +1,6 @@
+export { default as CircularPool } from './circular-pool';
+export { default as FixedArray } from './fixed-array';
+export { default as LinkedArray } from './linked-array';
+export { default as Pool } from './pool';
+export { default as RecyclePool } from './recycle-pool';
+export { default as TypedArrayPool } from './typed-array-pool';

engine/cocos2d/renderer/memop/linked-array.js

@@ -0,0 +1,82 @@
+import Pool from './pool';
+
+// NOTE: you must have `_prev` and `_next` field in the object returns by `fn`
+
+export default class LinkedArray {
+  constructor(fn, size) {
+    this._fn = fn;
+    this._count = 0;
+    this._head = null;
+    this._tail = null;
+
+    this._pool = new Pool(fn, size);
+  }
+
+  get head() {
+    return this._head;
+  }
+
+  get tail() {
+    return this._tail;
+  }
+
+  get length() {
+    return this._count;
+  }
+
+  add() {
+    let node = this._pool.alloc();
+
+    if (!this._tail) {
+      this._head = node;
+    } else {
+      this._tail._next = node;
+      node._prev = this._tail;
+    }
+    this._tail = node;
+    this._count += 1;
+
+    return node;
+  }
+
+  remove(node) {
+    if (node._prev) {
+      node._prev._next = node._next;
+    } else {
+      this._head = node._next;
+    }
+
+    if (node._next) {
+      node._next._prev = node._prev;
+    } else {
+      this._tail = node._prev;
+    }
+
+    node._next = null;
+    node._prev = null;
+    this._pool.free(node);
+    this._count -= 1;
+  }
+
+  forEach(fn, binder) {
+    let cursor = this._head;
+    if (!cursor) {
+      return;
+    }
+
+    if (binder) {
+      fn = fn.bind(binder);
+    }
+
+    let idx = 0;
+    let next = cursor;
+
+    while (cursor) {
+      next = cursor._next;
+      fn(cursor, idx, this);
+
+      cursor = next;
+      ++idx;
+    }
+  }
+}

engine/cocos2d/renderer/memop/optimized-array.js

@@ -0,0 +1,187 @@
+export class OptimizedArray {
+  /**
+   * Initialize this array with specified capacity.
+   * @param {Number} [size] The size. 
+   */
+  constructor(size = 0) {
+    this._size = size;
+    this._data = new Array(size);
+  }
+
+  /**
+   * Size of this array.
+   * @return {Number}
+   */
+  get size() {
+    return this._size;
+  }
+
+  /**
+   * The underlying Array of this array.
+   * @return {Array}
+   */
+  get data() {
+    return this._data;
+  }
+
+  /**
+   * Capacity of this array.
+   */
+  get capacity() {
+    return this._data.length;
+  }
+
+  /**
+   * Push a value to back of this array.
+   * @param {any} value 
+   */
+  push(value) {
+    if (this._size > this._data.length)
+      this._extends(this._data.length);
+    this._data[this._size] = value;
+    ++this._size;
+  }
+
+  /**
+   * Remove the last element and return it, if exists.
+   */
+  pop() {
+    if (this._size == 0)
+      return;
+    --this._size;
+    let ret = this._data[this._size];
+    this._data[this._size] = undefined;
+    return ret;
+  }
+
+  /**
+   * Remove all elements.
+   */
+  clear() {
+    for (let i = 0; i < this._data.length; ++i)
+      this._data[i] = undefined;
+    this._size = 0;
+  }
+
+  /**
+   * @ignore
+   * @param {Number} size 
+   */
+  _extends(size) {
+    let finalSize = this._data.length + size;
+    for (let i = this._data.length; i < finalSize; ++i)
+      this._data[i] = undefined;
+  }
+}
+
+export class OptimizedValueArray {
+  /**
+   * Initialize this array with specified capacity.
+   * @param {any} ctor The constructor to create the value.
+   * @param {Number} [size] The size. 
+   */
+  constructor(ctor, dtor, size = 0) {
+    this._size = size;
+    this._data = new Array();
+    this._ctor = ctor;
+    this._dtor = dtor;
+    this._extends(size);
+  }
+
+  /**
+   * Size of this array.
+   * @return {Number}
+   */
+  get size() {
+    return this._size;
+  }
+
+  /**
+   * The underlying Array of this array.
+   * @return {Array}
+   */
+  get data() {
+    return this._data;
+  }
+
+  /**
+   * Capacity of this array.
+   */
+  get capacity() {
+    return this._data.length;
+  }
+
+  /**
+   * Push a value to back of this array.
+   */
+  push() {
+    if (this._size >= this._data.length)
+      this._extends(this._data.length + 1);
+    let retval = this._data[this._size];
+    ++this._size;
+    return retval;
+  }
+
+  /**
+   * Remove the last element, if exists.
+   * Since that element is not erased, so we cannot return it.
+   */
+  pop() {
+    if (this._size == 0)
+      return;
+    --this._size;
+    this._dtor(this._data[this._size]);
+  }
+
+  /**
+   * Remove all elements.
+   */
+  clear() {
+    this._size = 0;
+    for (let i = 0; i < this._data.length; ++i)
+      this._dtor(this._data[i]);
+  }
+
+  splice(from, number) {
+    if (number == 0)
+      return;
+
+    if (from >= this.size)
+      return; // throw
+
+    number = Math.min(this.size - from, number);
+
+    let originalSize = this._size;
+    this._size -= number;
+
+    for (let i = 0, moveStart = from + number, moveNumber = originalSize - moveStart; i < moveNumber; ++i) {
+      let temp = this._data[from + i];
+      this._data[from + i] = this._data[moveStart + i];
+      this._data[moveStart + i] = temp;
+    }
+    for (let i = this._size; i != originalSize; ++i)
+      this._dtor(this._data[i]);
+  }
+
+  forEach(fx) {
+    for (let i = 0; i < this.size; ++i)
+      fx(this.data[i], i, this);
+  }
+
+  map(fx) {
+    let result = new Array();
+    for (let i = 0; i < this.size; ++i)
+      result.push(fx(this.data[i], i, this));
+    return result;
+  }
+
+  /**
+   * @ignore
+   * @param {Number} size 
+   */
+  _extends(size) {
+    let finalSize = this._data.length + size;
+    for (let i = this._data.length; i < finalSize; ++i)
+      this._data[i] = this._ctor();
+  }
+}

engine/cocos2d/renderer/memop/pool.js

@@ -0,0 +1,59 @@
+export default class Pool {
+  constructor(fn, size) {
+    this._fn = fn;
+    this._idx = size - 1;
+    this._frees = new Array(size);
+
+    for (let i = 0; i < size; ++i) {
+      this._frees[i] = fn();
+    }
+  }
+
+  _expand(size) {
+    let old = this._frees;
+    this._frees = new Array(size);
+
+    let len = size - old.length;
+    for (let i = 0; i < len; ++i) {
+      this._frees[i] = this._fn();
+    }
+
+    for (let i = len, j = 0; i < size; ++i, ++j) {
+      this._frees[i] = old[j];
+    }
+
+    this._idx += len;
+  }
+
+  alloc() {
+    // create some more space (expand by 20%, minimum 1)
+    if (this._idx < 0) {
+      this._expand(Math.round(this._frees.length * 1.2) + 1);
+    }
+
+    let ret = this._frees[this._idx];
+    this._frees[this._idx] = null;
+    --this._idx;
+
+    return ret;
+  }
+
+  free(obj) {
+    ++this._idx;
+    this._frees[this._idx] = obj;
+  }
+
+  /**
+   * 清除对象池。
+   * @param fn 清除回调，对每个释放的对象调用一次。
+   */
+  clear (fn) {
+    for (let i = 0; i <= this._idx; i++) {
+        if (fn) {
+            fn(this._frees[i]);
+        }
+    }
+    this._frees.length = 0;
+    this._idx = -1;
+  }
+}

engine/cocos2d/renderer/memop/recycle-pool.js

@@ -0,0 +1,63 @@
+import sort from './timsort';
+
+/**
+ * Recycle Pool
+ * @class RecyclePool
+ */
+export default class RecyclePool {
+  constructor(fn, size) {
+    this._fn = fn;
+    this._count = 0;
+    this._data = new Array(size);
+
+    for (let i = 0; i < size; ++i) {
+      this._data[i] = fn();
+    }
+  }
+
+  get length() {
+    return this._count;
+  }
+
+  get data() {
+    return this._data;
+  }
+
+  reset() {
+    this._count = 0;
+  }
+
+  resize(size) {
+    if (size > this._data.length) {
+      for (let i = this._data.length; i < size; ++i) {
+        this._data[i] = this._fn();
+      }
+    }
+  }
+
+  add() {
+    if (this._count >= this._data.length) {
+      this.resize(this._data.length * 2);
+    }
+
+    return this._data[this._count++];
+  }
+
+  remove(idx) {
+    if (idx >= this._count) {
+      return;
+    }
+
+    let last = this._count - 1;
+    let tmp = this._data[idx];
+    this._data[idx] = this._data[last];
+    this._data[last] = tmp;
+    this._count -= 1;
+  }
+
+  sort(cmp) {
+    return sort(this._data, 0, this._count, cmp);
+  }
+}
+
+cc.RecyclePool = RecyclePool;

engine/cocos2d/renderer/memop/sort.js

@@ -0,0 +1,166 @@
+// reference: https://github.com/v8/v8/blob/master/src/js/array.js
+
+function _compare(a, b) {
+  return a - b;
+}
+
+function _sort(array, from, to, comparefn) {
+
+  function _insertionSort(a, from, to) {
+    for (let i = from + 1; i < to; i++) {
+      let element = a[i];
+      let j;
+
+      for (j = i - 1; j >= from; j--) {
+        let tmp = a[j];
+        let order = comparefn(tmp, element);
+        if (order > 0) {
+          a[j + 1] = tmp;
+        } else {
+          break;
+        }
+      }
+      a[j + 1] = element;
+    }
+  }
+
+  // function _getThirdIndex(a, from, to) {
+  //   let t_array = new Array();
+  //   // Use both 'from' and 'to' to determine the pivot candidates.
+  //   let increment = 200 + ((to - from) & 15);
+  //   let j = 0;
+  //   from += 1;
+  //   to -= 1;
+  //   for (let i = from; i < to; i += increment) {
+  //     t_array[j] = [i, a[i]];
+  //     j++;
+  //   }
+  //   t_array.sort(function (a, b) {
+  //     return comparefn(a[1], b[1]);
+  //   });
+  //   let third_index = t_array[t_array.length >> 1][0];
+  //   return third_index;
+  // }
+
+  function _quickSort(a, from, to) {
+    let third_index = 0;
+
+    while (true) {
+      // Insertion sort is faster for short arrays.
+      if (to - from <= 10) {
+        _insertionSort(a, from, to);
+        return;
+      }
+      // if (to - from > 1000) {
+      //   third_index = _getThirdIndex(a, from, to);
+      // } else {
+        third_index = from + ((to - from) >> 1);
+      // }
+      // Find a pivot as the median of first, last and middle element.
+      let v0 = a[from];
+      let v1 = a[to - 1];
+      let v2 = a[third_index];
+      let c01 = comparefn(v0, v1);
+      if (c01 > 0) {
+        // v1 < v0, so swap them.
+        let tmp = v0;
+        v0 = v1;
+        v1 = tmp;
+      } // v0 <= v1.
+      let c02 = comparefn(v0, v2);
+      if (c02 >= 0) {
+        // v2 <= v0 <= v1.
+        let tmp = v0;
+        v0 = v2;
+        v2 = v1;
+        v1 = tmp;
+      } else {
+        // v0 <= v1 && v0 < v2
+        let c12 = comparefn(v1, v2);
+        if (c12 > 0) {
+          // v0 <= v2 < v1
+          let tmp = v1;
+          v1 = v2;
+          v2 = tmp;
+        }
+      }
+      // v0 <= v1 <= v2
+      a[from] = v0;
+      a[to - 1] = v2;
+      let pivot = v1;
+      let low_end = from + 1;   // Upper bound of elements lower than pivot.
+      let high_start = to - 1;  // Lower bound of elements greater than pivot.
+      a[third_index] = a[low_end];
+      a[low_end] = pivot;
+
+      // From low_end to i are elements equal to pivot.
+      // From i to high_start are elements that haven't been compared yet.
+      partition: for (let i = low_end + 1; i < high_start; i++) {
+        let element = a[i];
+        let order = comparefn(element, pivot);
+        if (order < 0) {
+          a[i] = a[low_end];
+          a[low_end] = element;
+          low_end++;
+        } else if (order > 0) {
+          do {
+            high_start--;
+            if (high_start == i) break partition;
+            let top_elem = a[high_start];
+            order = comparefn(top_elem, pivot);
+          } while (order > 0);
+          a[i] = a[high_start];
+          a[high_start] = element;
+          if (order < 0) {
+            element = a[i];
+            a[i] = a[low_end];
+            a[low_end] = element;
+            low_end++;
+          }
+        }
+      }
+      if (to - high_start < low_end - from) {
+        _quickSort(a, high_start, to);
+        to = low_end;
+      } else {
+        _quickSort(a, from, low_end);
+        from = high_start;
+      }
+    }
+  }
+
+  if (to - from < 2) {
+    return array;
+  }
+
+  _quickSort(array, from, to);
+
+  return array;
+}
+
+
+/**
+ * Calls the _quickSort function with it's initial values.
+ *
+ * @public
+ * @param {array} array The input array which should be sorted
+ * @param {Number} from
+ * @param {Number} to
+ * @param {Function} cmp
+ * @returns {array} array Sorted array
+ */
+export default function (array, from, to, cmp) {
+  if (from === undefined) {
+    from = 0;
+  }
+
+  if (to === undefined) {
+    to = array.length;
+  }
+
+  if (cmp === undefined) {
+    cmp = _compare;
+  }
+
+  return _sort(array, from, to, cmp);
+}

engine/cocos2d/renderer/memop/timsort.js

@@ -0,0 +1,967 @@
+// reference: https://github.com/mziccard/node-timsort
+
+/**
+ * Default minimum size of a run.
+ */
+const DEFAULT_MIN_MERGE = 32;
+
+/**
+ * Minimum ordered subsequece required to do galloping.
+ */
+const DEFAULT_MIN_GALLOPING = 7;
+
+/**
+ * Default tmp storage length. Can increase depending on the size of the
+ * smallest run to merge.
+ */
+const DEFAULT_TMP_STORAGE_LENGTH = 256;
+
+/**
+ * Pre-computed powers of 10 for efficient lexicographic comparison of
+ * small integers.
+ */
+const POWERS_OF_TEN = [1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9]
+
+/**
+ * Estimate the logarithm base 10 of a small integer.
+ *
+ * @param {number} x - The integer to estimate the logarithm of.
+ * @return {number} - The estimated logarithm of the integer.
+ */
+function log10(x) {
+  if (x < 1e5) {
+    if (x < 1e2) {
+      return x < 1e1 ? 0 : 1;
+    }
+
+    if (x < 1e4) {
+      return x < 1e3 ? 2 : 3;
+    }
+
+    return 4;
+  }
+
+  if (x < 1e7) {
+    return x < 1e6 ? 5 : 6;
+  }
+
+  if (x < 1e9) {
+    return x < 1e8 ? 7 : 8;
+  }
+
+  return 9;
+}
+
+/**
+ * Default alphabetical comparison of items.
+ *
+ * @param {string|object|number} a - First element to compare.
+ * @param {string|object|number} b - Second element to compare.
+ * @return {number} - A positive number if a.toString() > b.toString(), a
+ * negative number if .toString() < b.toString(), 0 otherwise.
+ */
+function alphabeticalCompare(a, b) {
+  if (a === b) {
+    return 0;
+  }
+
+  if (~~a === a && ~~b === b) {
+    if (a === 0 || b === 0) {
+      return a < b ? -1 : 1;
+    }
+
+    if (a < 0 || b < 0) {
+      if (b >= 0) {
+        return -1;
+      }
+
+      if (a >= 0) {
+        return 1;
+      }
+
+      a = -a;
+      b = -b;
+    }
+
+    const al = log10(a);
+    const bl = log10(b);
+
+    let t = 0;
+
+    if (al < bl) {
+      a *= POWERS_OF_TEN[bl - al - 1];
+      b /= 10;
+      t = -1;
+    } else if (al > bl) {
+      b *= POWERS_OF_TEN[al - bl - 1];
+      a /= 10;
+      t = 1;
+    }
+
+    if (a === b) {
+      return t;
+    }
+
+    return a < b ? -1 : 1;
+  }
+
+  let aStr = String(a);
+  let bStr = String(b);
+
+  if (aStr === bStr) {
+    return 0;
+  }
+
+  return aStr < bStr ? -1 : 1;
+}
+
+/**
+ * Compute minimum run length for TimSort
+ *
+ * @param {number} n - The size of the array to sort.
+ */
+function minRunLength(n) {
+  let r = 0;
+
+  while (n >= DEFAULT_MIN_MERGE) {
+    r |= (n & 1);
+    n >>= 1;
+  }
+
+  return n + r;
+}
+
+/**
+ * Counts the length of a monotonically ascending or strictly monotonically
+ * descending sequence (run) starting at array[lo] in the range [lo, hi). If
+ * the run is descending it is made ascending.
+ *
+ * @param {array} array - The array to reverse.
+ * @param {number} lo - First element in the range (inclusive).
+ * @param {number} hi - Last element in the range.
+ * @param {function} compare - Item comparison function.
+ * @return {number} - The length of the run.
+ */
+function makeAscendingRun(array, lo, hi, compare) {
+  let runHi = lo + 1;
+
+  if (runHi === hi) {
+    return 1;
+  }
+
+  // Descending
+  if (compare(array[runHi++], array[lo]) < 0) {
+    while (runHi < hi && compare(array[runHi], array[runHi - 1]) < 0) {
+      runHi++;
+    }
+
+    reverseRun(array, lo, runHi);
+    // Ascending
+  } else {
+    while (runHi < hi && compare(array[runHi], array[runHi - 1]) >= 0) {
+      runHi++;
+    }
+  }
+
+  return runHi - lo;
+}
+
+/**
+ * Reverse an array in the range [lo, hi).
+ *
+ * @param {array} array - The array to reverse.
+ * @param {number} lo - First element in the range (inclusive).
+ * @param {number} hi - Last element in the range.
+ */
+function reverseRun(array, lo, hi) {
+  hi--;
+
+  while (lo < hi) {
+    let t = array[lo];
+    array[lo++] = array[hi];
+    array[hi--] = t;
+  }
+}
+
+/**
+ * Perform the binary sort of the array in the range [lo, hi) where start is
+ * the first element possibly out of order.
+ *
+ * @param {array} array - The array to sort.
+ * @param {number} lo - First element in the range (inclusive).
+ * @param {number} hi - Last element in the range.
+ * @param {number} start - First element possibly out of order.
+ * @param {function} compare - Item comparison function.
+ */
+function binaryInsertionSort(array, lo, hi, start, compare) {
+  if (start === lo) {
+    start++;
+  }
+
+  for (; start < hi; start++) {
+    let pivot = array[start];
+
+    // Ranges of the array where pivot belongs
+    let left = lo;
+    let right = start;
+
+    /*
+     *   pivot >= array[i] for i in [lo, left)
+     *   pivot <  array[i] for i in  in [right, start)
+     */
+    while (left < right) {
+      let mid = (left + right) >>> 1;
+
+      if (compare(pivot, array[mid]) < 0) {
+        right = mid;
+      } else {
+        left = mid + 1;
+      }
+    }
+
+    /*
+     * Move elements right to make room for the pivot. If there are elements
+     * equal to pivot, left points to the first slot after them: this is also
+     * a reason for which TimSort is stable
+     */
+    let n = start - left;
+    // Switch is just an optimization for small arrays
+    switch (n) {
+      case 3:
+        array[left + 3] = array[left + 2];
+      /* falls through */
+      case 2:
+        array[left + 2] = array[left + 1];
+      /* falls through */
+      case 1:
+        array[left + 1] = array[left];
+        break;
+      default:
+        while (n > 0) {
+          array[left + n] = array[left + n - 1];
+          n--;
+        }
+    }
+
+    array[left] = pivot;
+  }
+}
+
+/**
+ * Find the position at which to insert a value in a sorted range. If the range
+ * contains elements equal to the value the leftmost element index is returned
+ * (for stability).
+ *
+ * @param {number} value - Value to insert.
+ * @param {array} array - The array in which to insert value.
+ * @param {number} start - First element in the range.
+ * @param {number} length - Length of the range.
+ * @param {number} hint - The index at which to begin the search.
+ * @param {function} compare - Item comparison function.
+ * @return {number} - The index where to insert value.
+ */
+function gallopLeft(value, array, start, length, hint, compare) {
+  let lastOffset = 0;
+  let maxOffset = 0;
+  let offset = 1;
+
+  if (compare(value, array[start + hint]) > 0) {
+    maxOffset = length - hint;
+
+    while (offset < maxOffset && compare(value, array[start + hint + offset]) > 0) {
+      lastOffset = offset;
+      offset = (offset << 1) + 1;
+
+      if (offset <= 0) {
+        offset = maxOffset;
+      }
+    }
+
+    if (offset > maxOffset) {
+      offset = maxOffset;
+    }
+
+    // Make offsets relative to start
+    lastOffset += hint;
+    offset += hint;
+
+    // value <= array[start + hint]
+  } else {
+    maxOffset = hint + 1;
+    while (offset < maxOffset && compare(value, array[start + hint - offset]) <= 0) {
+      lastOffset = offset;
+      offset = (offset << 1) + 1;
+
+      if (offset <= 0) {
+        offset = maxOffset;
+      }
+    }
+    if (offset > maxOffset) {
+      offset = maxOffset;
+    }
+
+    // Make offsets relative to start
+    let tmp = lastOffset;
+    lastOffset = hint - offset;
+    offset = hint - tmp;
+  }
+
+  /*
+   * Now array[start+lastOffset] < value <= array[start+offset], so value
+   * belongs somewhere in the range (start + lastOffset, start + offset]. Do a
+   * binary search, with invariant array[start + lastOffset - 1] < value <=
+   * array[start + offset].
+   */
+  lastOffset++;
+  while (lastOffset < offset) {
+    let m = lastOffset + ((offset - lastOffset) >>> 1);
+
+    if (compare(value, array[start + m]) > 0) {
+      lastOffset = m + 1;
+
+    } else {
+      offset = m;
+    }
+  }
+  return offset;
+}
+
+/**
+ * Find the position at which to insert a value in a sorted range. If the range
+ * contains elements equal to the value the rightmost element index is returned
+ * (for stability).
+ *
+ * @param {number} value - Value to insert.
+ * @param {array} array - The array in which to insert value.
+ * @param {number} start - First element in the range.
+ * @param {number} length - Length of the range.
+ * @param {number} hint - The index at which to begin the search.
+ * @param {function} compare - Item comparison function.
+ * @return {number} - The index where to insert value.
+ */
+function gallopRight(value, array, start, length, hint, compare) {
+  let lastOffset = 0;
+  let maxOffset = 0;
+  let offset = 1;
+
+  if (compare(value, array[start + hint]) < 0) {
+    maxOffset = hint + 1;
+
+    while (offset < maxOffset && compare(value, array[start + hint - offset]) < 0) {
+      lastOffset = offset;
+      offset = (offset << 1) + 1;
+
+      if (offset <= 0) {
+        offset = maxOffset;
+      }
+    }
+
+    if (offset > maxOffset) {
+      offset = maxOffset;
+    }
+
+    // Make offsets relative to start
+    let tmp = lastOffset;
+    lastOffset = hint - offset;
+    offset = hint - tmp;
+
+    // value >= array[start + hint]
+  } else {
+    maxOffset = length - hint;
+
+    while (offset < maxOffset && compare(value, array[start + hint + offset]) >= 0) {
+      lastOffset = offset;
+      offset = (offset << 1) + 1;
+
+      if (offset <= 0) {
+        offset = maxOffset;
+      }
+    }
+
+    if (offset > maxOffset) {
+      offset = maxOffset;
+    }
+
+    // Make offsets relative to start
+    lastOffset += hint;
+    offset += hint;
+  }
+
+  /*
+   * Now array[start+lastOffset] < value <= array[start+offset], so value
+   * belongs somewhere in the range (start + lastOffset, start + offset]. Do a
+   * binary search, with invariant array[start + lastOffset - 1] < value <=
+   * array[start + offset].
+   */
+  lastOffset++;
+
+  while (lastOffset < offset) {
+    let m = lastOffset + ((offset - lastOffset) >>> 1);
+
+    if (compare(value, array[start + m]) < 0) {
+      offset = m;
+
+    } else {
+      lastOffset = m + 1;
+    }
+  }
+
+  return offset;
+}
+
+class TimSort {
+
+  constructor(array, compare) {
+    this.array = array;
+    this.compare = compare;
+    this.minGallop = DEFAULT_MIN_GALLOPING;
+    this.length = array.length;
+
+    this.tmpStorageLength = DEFAULT_TMP_STORAGE_LENGTH;
+    if (this.length < 2 * DEFAULT_TMP_STORAGE_LENGTH) {
+      this.tmpStorageLength = this.length >>> 1;
+    }
+
+    this.tmp = new Array(this.tmpStorageLength);
+
+    this.stackLength =
+      (this.length < 120 ? 5 :
+        this.length < 1542 ? 10 :
+          this.length < 119151 ? 19 : 40);
+
+    this.runStart = new Array(this.stackLength);
+    this.runLength = new Array(this.stackLength);
+    this.stackSize = 0;
+  }
+
+  /**
+   * Push a new run on TimSort's stack.
+   *
+   * @param {number} runStart - Start index of the run in the original array.
+   * @param {number} runLength - Length of the run;
+   */
+  pushRun(runStart, runLength) {
+    this.runStart[this.stackSize] = runStart;
+    this.runLength[this.stackSize] = runLength;
+    this.stackSize += 1;
+  }
+
+  /**
+   * Merge runs on TimSort's stack so that the following holds for all i:
+   * 1) runLength[i - 3] > runLength[i - 2] + runLength[i - 1]
+   * 2) runLength[i - 2] > runLength[i - 1]
+   */
+  mergeRuns() {
+    while (this.stackSize > 1) {
+      let n = this.stackSize - 2;
+
+      if ((n >= 1 &&
+        this.runLength[n - 1] <= this.runLength[n] + this.runLength[n + 1]) ||
+        (n >= 2 &&
+        this.runLength[n - 2] <= this.runLength[n] + this.runLength[n - 1])) {
+
+        if (this.runLength[n - 1] < this.runLength[n + 1]) {
+          n--;
+        }
+
+      } else if (this.runLength[n] > this.runLength[n + 1]) {
+        break;
+      }
+      this.mergeAt(n);
+    }
+  }
+
+  /**
+   * Merge all runs on TimSort's stack until only one remains.
+   */
+  forceMergeRuns() {
+    while (this.stackSize > 1) {
+      let n = this.stackSize - 2;
+
+      if (n > 0 && this.runLength[n - 1] < this.runLength[n + 1]) {
+        n--;
+      }
+
+      this.mergeAt(n);
+    }
+  }
+
+  /**
+   * Merge the runs on the stack at positions i and i+1. Must be always be called
+   * with i=stackSize-2 or i=stackSize-3 (that is, we merge on top of the stack).
+   *
+   * @param {number} i - Index of the run to merge in TimSort's stack.
+   */
+  mergeAt(i) {
+    let compare = this.compare;
+    let array = this.array;
+
+    let start1 = this.runStart[i];
+    let length1 = this.runLength[i];
+    let start2 = this.runStart[i + 1];
+    let length2 = this.runLength[i + 1];
+
+    this.runLength[i] = length1 + length2;
+
+    if (i === this.stackSize - 3) {
+      this.runStart[i + 1] = this.runStart[i + 2];
+      this.runLength[i + 1] = this.runLength[i + 2];
+    }
+
+    this.stackSize--;
+
+    /*
+     * Find where the first element in the second run goes in run1. Previous
+     * elements in run1 are already in place
+     */
+    let k = gallopRight(array[start2], array, start1, length1, 0, compare);
+    start1 += k;
+    length1 -= k;
+
+    if (length1 === 0) {
+      return;
+    }
+
+    /*
+     * Find where the last element in the first run goes in run2. Next elements
+     * in run2 are already in place
+     */
+    length2 = gallopLeft(array[start1 + length1 - 1], array, start2, length2, length2 - 1, compare);
+
+    if (length2 === 0) {
+      return;
+    }
+
+    /*
+     * Merge remaining runs. A tmp array with length = min(length1, length2) is
+     * used
+     */
+    if (length1 <= length2) {
+      this.mergeLow(start1, length1, start2, length2);
+
+    } else {
+      this.mergeHigh(start1, length1, start2, length2);
+    }
+  }
+
+  /**
+   * Merge two adjacent runs in a stable way. The runs must be such that the
+   * first element of run1 is bigger than the first element in run2 and the
+   * last element of run1 is greater than all the elements in run2.
+   * The method should be called when run1.length <= run2.length as it uses
+   * TimSort temporary array to store run1. Use mergeHigh if run1.length >
+   * run2.length.
+   *
+   * @param {number} start1 - First element in run1.
+   * @param {number} length1 - Length of run1.
+   * @param {number} start2 - First element in run2.
+   * @param {number} length2 - Length of run2.
+   */
+  mergeLow(start1, length1, start2, length2) {
+
+    let compare = this.compare;
+    let array = this.array;
+    let tmp = this.tmp;
+    let i = 0;
+
+    for (i = 0; i < length1; i++) {
+      tmp[i] = array[start1 + i];
+    }
+
+    let cursor1 = 0;
+    let cursor2 = start2;
+    let dest = start1;
+
+    array[dest++] = array[cursor2++];
+
+    if (--length2 === 0) {
+      for (i = 0; i < length1; i++) {
+        array[dest + i] = tmp[cursor1 + i];
+      }
+      return;
+    }
+
+    if (length1 === 1) {
+      for (i = 0; i < length2; i++) {
+        array[dest + i] = array[cursor2 + i];
+      }
+      array[dest + length2] = tmp[cursor1];
+      return;
+    }
+
+    let minGallop = this.minGallop;
+
+    while (true) {
+      let count1 = 0;
+      let count2 = 0;
+      let exit = false;
+
+      do {
+        if (compare(array[cursor2], tmp[cursor1]) < 0) {
+          array[dest++] = array[cursor2++];
+          count2++;
+          count1 = 0;
+
+          if (--length2 === 0) {
+            exit = true;
+            break;
+          }
+
+        } else {
+          array[dest++] = tmp[cursor1++];
+          count1++;
+          count2 = 0;
+          if (--length1 === 1) {
+            exit = true;
+            break;
+          }
+        }
+      } while ((count1 | count2) < minGallop);
+
+      if (exit) {
+        break;
+      }
+
+      do {
+        count1 = gallopRight(array[cursor2], tmp, cursor1, length1, 0, compare);
+
+        if (count1 !== 0) {
+          for (i = 0; i < count1; i++) {
+            array[dest + i] = tmp[cursor1 + i];
+          }
+
+          dest += count1;
+          cursor1 += count1;
+          length1 -= count1;
+          if (length1 <= 1) {
+            exit = true;
+            break;
+          }
+        }
+
+        array[dest++] = array[cursor2++];
+
+        if (--length2 === 0) {
+          exit = true;
+          break;
+        }
+
+        count2 = gallopLeft(tmp[cursor1], array, cursor2, length2, 0, compare);
+
+        if (count2 !== 0) {
+          for (i = 0; i < count2; i++) {
+            array[dest + i] = array[cursor2 + i];
+          }
+
+          dest += count2;
+          cursor2 += count2;
+          length2 -= count2;
+
+          if (length2 === 0) {
+            exit = true;
+            break;
+          }
+        }
+        array[dest++] = tmp[cursor1++];
+
+        if (--length1 === 1) {
+          exit = true;
+          break;
+        }
+
+        minGallop--;
+
+      } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
+
+      if (exit) {
+        break;
+      }
+
+      if (minGallop < 0) {
+        minGallop = 0;
+      }
+
+      minGallop += 2;
+    }
+
+    this.minGallop = minGallop;
+
+    if (minGallop < 1) {
+      this.minGallop = 1;
+    }
+
+    if (length1 === 1) {
+      for (i = 0; i < length2; i++) {
+        array[dest + i] = array[cursor2 + i];
+      }
+      array[dest + length2] = tmp[cursor1];
+
+    } else if (length1 === 0) {
+      throw new Error('mergeLow preconditions were not respected');
+
+    } else {
+      for (i = 0; i < length1; i++) {
+        array[dest + i] = tmp[cursor1 + i];
+      }
+    }
+  }
+
+  /**
+   * Merge two adjacent runs in a stable way. The runs must be such that the
+   * first element of run1 is bigger than the first element in run2 and the
+   * last element of run1 is greater than all the elements in run2.
+   * The method should be called when run1.length > run2.length as it uses
+   * TimSort temporary array to store run2. Use mergeLow if run1.length <=
+   * run2.length.
+   *
+   * @param {number} start1 - First element in run1.
+   * @param {number} length1 - Length of run1.
+   * @param {number} start2 - First element in run2.
+   * @param {number} length2 - Length of run2.
+   */
+  mergeHigh(start1, length1, start2, length2) {
+    let compare = this.compare;
+    let array = this.array;
+    let tmp = this.tmp;
+    let i = 0;
+
+    for (i = 0; i < length2; i++) {
+      tmp[i] = array[start2 + i];
+    }
+
+    let cursor1 = start1 + length1 - 1;
+    let cursor2 = length2 - 1;
+    let dest = start2 + length2 - 1;
+    let customCursor = 0;
+    let customDest = 0;
+
+    array[dest--] = array[cursor1--];
+
+    if (--length1 === 0) {
+      customCursor = dest - (length2 - 1);
+
+      for (i = 0; i < length2; i++) {
+        array[customCursor + i] = tmp[i];
+      }
+
+      return;
+    }
+
+    if (length2 === 1) {
+      dest -= length1;
+      cursor1 -= length1;
+      customDest = dest + 1;
+      customCursor = cursor1 + 1;
+
+      for (i = length1 - 1; i >= 0; i--) {
+        array[customDest + i] = array[customCursor + i];
+      }
+
+      array[dest] = tmp[cursor2];
+      return;
+    }
+
+    let minGallop = this.minGallop;
+
+    while (true) {
+      let count1 = 0;
+      let count2 = 0;
+      let exit = false;
+
+      do {
+        if (compare(tmp[cursor2], array[cursor1]) < 0) {
+          array[dest--] = array[cursor1--];
+          count1++;
+          count2 = 0;
+          if (--length1 === 0) {
+            exit = true;
+            break;
+          }
+
+        } else {
+          array[dest--] = tmp[cursor2--];
+          count2++;
+          count1 = 0;
+          if (--length2 === 1) {
+            exit = true;
+            break;
+          }
+        }
+
+      } while ((count1 | count2) < minGallop);
+
+      if (exit) {
+        break;
+      }
+
+      do {
+        count1 = length1 - gallopRight(tmp[cursor2], array, start1, length1, length1 - 1, compare);
+
+        if (count1 !== 0) {
+          dest -= count1;
+          cursor1 -= count1;
+          length1 -= count1;
+          customDest = dest + 1;
+          customCursor = cursor1 + 1;
+
+          for (i = count1 - 1; i >= 0; i--) {
+            array[customDest + i] = array[customCursor + i];
+          }
+
+          if (length1 === 0) {
+            exit = true;
+            break;
+          }
+        }
+
+        array[dest--] = tmp[cursor2--];
+
+        if (--length2 === 1) {
+          exit = true;
+          break;
+        }
+
+        count2 = length2 - gallopLeft(array[cursor1], tmp, 0, length2, length2 - 1, compare);
+
+        if (count2 !== 0) {
+          dest -= count2;
+          cursor2 -= count2;
+          length2 -= count2;
+          customDest = dest + 1;
+          customCursor = cursor2 + 1;
+
+          for (i = 0; i < count2; i++) {
+            array[customDest + i] = tmp[customCursor + i];
+          }
+
+          if (length2 <= 1) {
+            exit = true;
+            break;
+          }
+        }
+
+        array[dest--] = array[cursor1--];
+
+        if (--length1 === 0) {
+          exit = true;
+          break;
+        }
+
+        minGallop--;
+
+      } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
+
+      if (exit) {
+        break;
+      }
+
+      if (minGallop < 0) {
+        minGallop = 0;
+      }
+
+      minGallop += 2;
+    }
+
+    this.minGallop = minGallop;
+
+    if (minGallop < 1) {
+      this.minGallop = 1;
+    }
+
+    if (length2 === 1) {
+      dest -= length1;
+      cursor1 -= length1;
+      customDest = dest + 1;
+      customCursor = cursor1 + 1;
+
+      for (i = length1 - 1; i >= 0; i--) {
+        array[customDest + i] = array[customCursor + i];
+      }
+
+      array[dest] = tmp[cursor2];
+
+    } else if (length2 === 0) {
+      throw new Error('mergeHigh preconditions were not respected');
+
+    } else {
+      customCursor = dest - (length2 - 1);
+      for (i = 0; i < length2; i++) {
+        array[customCursor + i] = tmp[i];
+      }
+    }
+  }
+}
+
+/**
+ * Sort an array in the range [lo, hi) using TimSort.
+ *
+ * @param {array} array - The array to sort.
+ * @param {number} lo - First element in the range (inclusive).
+ * @param {number} hi - Last element in the range.
+ * @param {function=} compare - Item comparison function. Default is alphabetical.
+ */
+export default function (array, lo, hi, compare) {
+  if (!Array.isArray(array)) {
+    throw new TypeError('Can only sort arrays');
+  }
+
+  /*
+   * Handle the case where a comparison function is not provided. We do
+   * lexicographic sorting
+   */
+
+  if (lo === undefined) {
+    lo = 0;
+  }
+
+  if (hi === undefined) {
+    hi = array.length;
+  }
+
+  if (compare === undefined) {
+    compare = alphabeticalCompare;
+  }
+
+  let remaining = hi - lo;
+
+  // The array is already sorted
+  if (remaining < 2) {
+    return;
+  }
+
+  let runLength = 0;
+  // On small arrays binary sort can be used directly
+  if (remaining < DEFAULT_MIN_MERGE) {
+    runLength = makeAscendingRun(array, lo, hi, compare);
+    binaryInsertionSort(array, lo, hi, lo + runLength, compare);
+    return;
+  }
+
+  let ts = new TimSort(array, compare);
+
+  let minRun = minRunLength(remaining);
+
+  do {
+    runLength = makeAscendingRun(array, lo, hi, compare);
+    if (runLength < minRun) {
+      let force = remaining;
+      if (force > minRun) {
+        force = minRun;
+      }
+
+      binaryInsertionSort(array, lo, lo + force, lo + runLength, compare);
+      runLength = force;
+    }
+    // Push new run and merge if necessary
+    ts.pushRun(lo, runLength);
+    ts.mergeRuns();
+
+    // Go find next run
+    remaining -= runLength;
+    lo += runLength;
+
+  } while (remaining !== 0);
+
+  // Force merging of remaining runs
+  ts.forceMergeRuns();
+}

engine/cocos2d/renderer/memop/typed-array-pool.js

@@ -0,0 +1,129 @@
+let _bufferPools = Array(8);
+for (let i = 0; i < 8; ++i) {
+  _bufferPools[i] = [];
+}
+
+function _nextPow16(v) {
+  for (let i = 16; i <= (1 << 28); i *= 16) {
+    if (v <= i) {
+      return i;
+    }
+  }
+  return 0;
+}
+
+function _log2(v) {
+  let r, shift;
+  r = (v > 0xFFFF) << 4; v >>>= r;
+  shift = (v > 0xFF) << 3; v >>>= shift; r |= shift;
+  shift = (v > 0xF) << 2; v >>>= shift; r |= shift;
+  shift = (v > 0x3) << 1; v >>>= shift; r |= shift;
+  return r | (v >> 1);
+}
+
+function _alloc(n) {
+  let sz = _nextPow16(n);
+  let bin = _bufferPools[_log2(sz) >> 2];
+  if (bin.length > 0) {
+    return bin.pop();
+  }
+  return new ArrayBuffer(sz);
+}
+
+function _free(buf) {
+  _bufferPools[_log2(buf.byteLength) >> 2].push(buf);
+}
+
+export default {
+  alloc_int8(n) {
+    let result = new Int8Array(_alloc(n), 0, n);
+    if (result.length !== n) {
+      return result.subarray(0, n);
+    }
+
+    return result;
+  },
+
+  alloc_uint8(n) {
+    let result = new Uint8Array(_alloc(n), 0, n);
+    if (result.length !== n) {
+      return result.subarray(0, n);
+    }
+
+    return result;
+  },
+
+  alloc_int16(n) {
+    let result = new Int16Array(_alloc(2 * n), 0, n);
+    if (result.length !== n) {
+      return result.subarray(0, n);
+    }
+
+    return result;
+  },
+
+  alloc_uint16(n) {
+    let result = new Uint16Array(_alloc(2 * n), 0, n);
+    if (result.length !== n) {
+      return result.subarray(0, n);
+    }
+
+    return result;
+  },
+
+  alloc_int32(n) {
+    let result = new Int32Array(_alloc(4 * n), 0, n);
+    if (result.length !== n) {
+      return result.subarray(0, n);
+    }
+
+    return result;
+  },
+
+  alloc_uint32(n) {
+    let result = new Uint32Array(_alloc(4 * n), 0, n);
+    if (result.length !== n) {
+      return result.subarray(0, n);
+    }
+
+    return result;
+  },
+
+  alloc_float32(n) {
+    let result = new Float32Array(_alloc(4 * n), 0, n);
+    if (result.length !== n) {
+      return result.subarray(0, n);
+    }
+
+    return result;
+  },
+
+  alloc_float64(n) {
+    let result = new Float64Array(_alloc(8 * n), 0, n);
+    if (result.length !== n) {
+      return result.subarray(0, n);
+    }
+
+    return result;
+  },
+
+  alloc_dataview(n) {
+    let result = new DataView(_alloc(n), 0, n);
+    if (result.length !== n) {
+      return result.subarray(0, n);
+    }
+
+    return result;
+  },
+
+  free(array) {
+    _free(array.buffer);
+  },
+
+  reset() {
+    let _bufferPools = Array(8);
+    for (let i = 0; i < 8; ++i) {
+      _bufferPools[i] = [];
+    }
+  },
+};