@woosh/meep-engine 2.108.0 → 2.108.3

package/editor/tools/paint/TerrainHeightPaintTool.js

@@ -1,13 +1,13 @@
+import { uint8_to_float } from "../../../src/core/binary/uint8_to_float.js";
+import { QuadTreeNode } from "../../../src/core/geom/2d/quad-tree/QuadTreeNode.js";
 import { clamp } from "../../../src/core/math/clamp.js";
 import { inverseLerp } from "../../../src/core/math/inverseLerp.js";
 import { lerp } from "../../../src/core/math/lerp.js";
-import { TerrainPaintTool } from "./TerrainPaintTool.js";
-import { PatchTerrainHeightAction } from "../../actions/concrete/PatchTerrainHeightAction.js";
-import { QuadTreeNode } from "../../../src/core/geom/2d/quad-tree/QuadTreeNode.js";
 import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import { PatchTerrainHeightAction } from "../../actions/concrete/PatchTerrainHeightAction.js";
 import TransformModifyAction from "../../actions/concrete/TransformModifyAction.js";
 import EditorEntity from "../../ecs/EditorEntity.js";
-import { uint82float } from "../../../src/core/binary/uint82float.js";
+import { TerrainPaintTool } from "./TerrainPaintTool.js";
 
 const LIMIT_VALUE = 1000;
 
@@ -56,7 +56,7 @@ function make_mod_action(terrain, uv_x0, uv_y0, uv_x1, uv_y1, marker, value_delt
             //Get alpha
             const markerValue = marker.sampleChannelBilinearUV(u, v, 3);
 
-            const marker_value_normalized = uint82float(markerValue);
+            const marker_value_normalized = uint8_to_float(markerValue);
 
             const source_address = y * heightMap.width + x;
 

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.108.0",
+  "version": "2.108.3",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/binary/float_to_uint8.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {number} v
+ * @returns {number}
+ */
+export function float_to_uint8(v: number): number;
+//# sourceMappingURL=float_to_uint8.d.ts.map

package/src/core/binary/float_to_uint8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"float_to_uint8.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/float_to_uint8.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,kCAHW,MAAM,GACJ,MAAM,CAIlB"}

package/src/core/binary/{float2uint8.js → float_to_uint8.js}

@@ -3,6 +3,6 @@
  * @param {number} v
  * @returns {number}
  */
-export function float2uint8(v) {
+export function float_to_uint8(v) {
     return Math.round(v * 255);
 }

package/src/core/binary/uint8_to_float.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {number} v
+ * @returns {number}
+ */
+export function uint8_to_float(v: number): number;
+//# sourceMappingURL=uint8_to_float.d.ts.map

package/src/core/binary/uint8_to_float.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uint8_to_float.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/uint8_to_float.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,kCAHW,MAAM,GACJ,MAAM,CAIlB"}

package/src/core/binary/{uint82float.js → uint8_to_float.js}

@@ -3,6 +3,6 @@
  * @param {number} v
  * @returns {number}
  */
-export function uint82float(v) {
+export function uint8_to_float(v) {
     return v / 255;
 }

package/src/core/binary/uint8_to_float.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=uint8_to_float.spec.d.ts.map

package/src/core/binary/uint8_to_float.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uint8_to_float.spec.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/uint8_to_float.spec.js"],"names":[],"mappings":""}

package/src/core/binary/uint8_to_float.spec.js

@@ -0,0 +1,7 @@
+import { uint8_to_float } from "./uint8_to_float.js";
+
+test("correctness", () => {
+    expect(uint8_to_float(0)).toBe(0);
+    expect(uint8_to_float(1)).toBeCloseTo(1 / 255);
+    expect(uint8_to_float(255)).toBe(1);
+});

package/src/core/bvh2/binary/2/BinaryUint32BVH.d.ts

@@ -78,6 +78,12 @@ export class BinaryUint32BVH {
      * @param {number} count
      */
     setLeafCount(count: number): void;
+    /**
+     *
+     * @param {number} index
+     * @return {number}
+     */
+    getLeafAddress(index: number): number;
     /**
      *
      * @param {number} index

package/src/core/bvh2/binary/2/BinaryUint32BVH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinaryUint32BVH.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/binary/2/BinaryUint32BVH.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;GAIG;AACH,mCAFU,MAAM,CAEsB;AACtC;;;GAGG;AACH,iCAFU,MAAM,CAEoB;AAiDpC;IACI;;;;OAIG;IACH,sBAAc;IAEd;;;;OAIG;IACH,gCAAe;IAEf;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IA0CtB;;;OAGG;IACH,2BAOC;IAED,wBAEC;IAnDD;;;OAGG;IACH,oBAFa,MAAM,CAIlB;IAED,2BAEC;IAED,gCAEC;IAED,8BAEC;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED,4BAEC;IAED,0BAEC;IAmBD;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAalB;IAED,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAgBhB;IAED;;;;;;;;;;OAUG;IACH,mBATW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAsChB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,sBACrB,MAAM,QAIhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAED,qCAoBC;IAED;;;;;;;OAOG;IACH,yCAYC;IAED;;;;;;OAMG;IACH,kDAuBC;IAED,wBAUC;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAkElB;IAED;;;;;OAKG;IACH,sBAUC;IAED;;OAEG;IACH,cAsEC;CACJ"}
+{"version":3,"file":"BinaryUint32BVH.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/binary/2/BinaryUint32BVH.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;GAIG;AACH,mCAFU,MAAM,CAEsB;AACtC;;;GAGG;AACH,iCAFU,MAAM,CAEoB;AAiDpC;IACI;;;;OAIG;IACH,sBAAc;IAEd;;;;OAIG;IACH,gCAAe;IAEf;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IA0CtB;;;OAGG;IACH,2BAOC;IAED,wBAEC;IAnDD;;;OAGG;IACH,oBAFa,MAAM,CAIlB;IAED,2BAEC;IAED,gCAEC;IAED,8BAEC;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED,4BAEC;IAED,0BAEC;IAmBD;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAalB;IAED,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAgBhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,MAAM,CASjB;IAED;;;;;;;;;;OAUG;IACH,mBATW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAoChB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,sBACrB,MAAM,QAIhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAED,qCAoBC;IAED;;;;;;;OAOG;IACH,yCAYC;IAED;;;;;;OAMG;IACH,kDAuBC;IAED,wBAUC;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAkElB;IAED;;;;;OAKG;IACH,sBAUC;IAED;;OAEG;IACH,cAsEC;CACJ"}

package/src/core/bvh2/binary/2/BinaryUint32BVH.js

@@ -219,6 +219,20 @@ export class BinaryUint32BVH {
 
     }
 
+    /**
+     *
+     * @param {number} index
+     * @return {number}
+     */
+    getLeafAddress(index) {
+        assert.isNonNegativeInteger(index, 'index');
+        assert.lessThan(index, this.__node_count_leaf, 'leaf index overflow');
+
+        const leaf_block_address = this.__node_count_binary * BVH_BINARY_NODE_SIZE;
+
+        return index * BVH_LEAF_NODE_SIZE + leaf_block_address;
+    }
+
     /**
      *
      * @param {number} index
@@ -254,9 +268,7 @@ export class BinaryUint32BVH {
 
         assert.isNonNegativeInteger(payload, 'payload');
 
-        const leaf_block_address = this.__node_count_binary * BVH_BINARY_NODE_SIZE;
-
-        const address = index * BVH_LEAF_NODE_SIZE + leaf_block_address;
+        const address = this.getLeafAddress(index);
 
         aabb3_array_set(
             this.__data_float32,

package/src/core/bvh2/bvh3/build_triangle_morton_codes.js

@@ -34,7 +34,6 @@ export function build_triangle_morton_codes(
     // compute morton codes
     for (let i = 0; i < tri_count; i++) {
 
-
         const i3 = i * 3;
 
         // read indices
@@ -44,16 +43,17 @@ export function build_triangle_morton_codes(
 
         // read vertex positions
         const a_address = a * 3;
+        const c_address = c * 3;
+        const b_address = b * 3;
+
         const ax = position_array[a_address];
         const ay = position_array[a_address + 1];
         const az = position_array[a_address + 2];
 
-        const b_address = b * 3;
         const bx = position_array[b_address];
         const by = position_array[b_address + 1];
         const bz = position_array[b_address + 2];
 
-        const c_address = c * 3;
         const cx = position_array[c_address];
         const cy = position_array[c_address + 1];
         const cz = position_array[c_address + 2];

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_build_for_geometry_morton.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH,sEAHW,MAAM,EAAE,GAAC,YAAY,kBACrB,MAAM,EAAE,GAAC,YAAY,QA0E/B"}
+{"version":3,"file":"ebvh_build_for_geometry_morton.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js"],"names":[],"mappings":"AAWA;;;;;;GAMG;AACH,sEAHW,MAAM,EAAE,GAAC,YAAY,kBACrB,MAAM,EAAE,GAAC,YAAY,QAoF/B"}

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js

@@ -1,11 +1,12 @@
-import { compute_triangle_group_aabb3 } from "../../../engine/graphics/sh3/path_tracer/compute_triangle_group_aabb3.js";
 import { assert } from "../../assert.js";
-import { arrayQuickSort } from "../../collection/array/arrayQuickSort.js";
+import { array_copy } from "../../collection/array/array_copy.js";
+import { array_quick_sort_by_lookup } from "../../collection/array/array_quick_sort_by_lookup.js";
 import { AABB3 } from "../../geom/3d/aabb/AABB3.js";
 import { aabb3_from_v3_array } from "../../geom/3d/aabb/aabb3_from_v3_array.js";
+import { aabb3_compute_from_triangle } from "../../geom/3d/aabb3_compute_from_triangle.js";
 import { max2 } from "../../math/max2.js";
 import { build_triangle_morton_codes } from "./build_triangle_morton_codes.js";
-import { NULL_NODE } from "./BVH.js";
+import { ELEMENT_WORD_COUNT, NULL_NODE } from "./BVH.js";
 import { ebvh_build_hierarchy } from "./ebvh_build_hierarchy.js";
 
 /**
@@ -50,7 +51,6 @@ export function ebvh_build_for_geometry_morton(bvh, index_array, position_array)
         nodes[i] = (node_total_count - 1) - i;
     }
 
-    const morton_codes = new Uint32Array(tri_count);
 
     // indices of triangles, but sorted by morton codes
     const sorted_triangle_order = new Uint32Array(tri_count);
@@ -59,32 +59,43 @@ export function ebvh_build_for_geometry_morton(bvh, index_array, position_array)
         sorted_triangle_order[i] = i;
     }
 
+    const morton_codes = new Uint32Array(tri_count);
+
     build_triangle_morton_codes(morton_codes, tri_count, index_array, position_array, aabb3.x0, aabb3.y0, aabb3.z0, aabb3.x1, aabb3.y1, aabb3.z1);
 
     // sort leaves by morton codes
-    arrayQuickSort(sorted_triangle_order, (triangle_index) => morton_codes[triangle_index], null, 0, tri_count - 1);
+    array_quick_sort_by_lookup(sorted_triangle_order, morton_codes, 0, tri_count - 1);
 
-    let used_index = 0;
-    const unprocessed_nodes = new Uint32Array(tri_count);
     // assign leaves
-    const aabb_array = new Float32Array(6);
     for (let i = 0; i < tri_count; i++) {
-        const node = nodes[used_index++];
+        const node = nodes[i];
 
         const triangle_index = sorted_triangle_order[i];
 
-        bvh.node_set_child1(node, NULL_NODE);
+        bvh.node_set_child1(node, NULL_NODE); //mark node as a leaf
         bvh.node_set_user_data(node, triangle_index);
 
         bvh.node_set_height(node, 0);
 
-        compute_triangle_group_aabb3(aabb_array, 0, index_array, position_array, triangle_index * 3, 1, 3);
+        const triangle_index3 = triangle_index * 3;
 
-        bvh.node_set_aabb(node, aabb_array);
+        const a_index = index_array[triangle_index3];
+        const b_index = index_array[triangle_index3 + 1];
+        const c_index = index_array[triangle_index3 + 2];
+
+        const aabb_address = ELEMENT_WORD_COUNT * node;
+
+        aabb3_compute_from_triangle(
+            bvh.__data_float32, aabb_address,
+            position_array, a_index, b_index, c_index
+        );
 
-        unprocessed_nodes[i] = node;
     }
 
+    // record newly generated nodes as "unprocessed"
+    const unprocessed_nodes = new Uint32Array(tri_count);
+    array_copy(nodes, 0, unprocessed_nodes, 0, tri_count);
+
     // assign root
-    bvh.__root = ebvh_build_hierarchy(bvh, unprocessed_nodes, tri_count, nodes, used_index);
+    bvh.__root = ebvh_build_hierarchy(bvh, unprocessed_nodes, tri_count, nodes, tri_count);
 }

package/src/core/codegen/codeToBlob.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {string} code
+ * @param {string} [mime_type]
+ * @return {Blob}
+ */
+export function codeToBlob(code: string, mime_type?: string): Blob;
+//# sourceMappingURL=codeToBlob.d.ts.map

package/src/core/codegen/codeToBlob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeToBlob.d.ts","sourceRoot":"","sources":["../../../../src/core/codegen/codeToBlob.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,iCAJW,MAAM,cACN,MAAM,GACL,IAAI,CA6Bf"}

package/src/core/codegen/codeToBlob.js

@@ -0,0 +1,36 @@
+import { assert } from "../assert.js";
+
+/**
+ *
+ * @param {string} code
+ * @param {string} [mime_type]
+ * @return {Blob}
+ */
+export function codeToBlob(code, mime_type = 'application/javascript') {
+    assert.isString(code, 'code');
+    assert.isString(mime_type, 'mime_type');
+
+    let blob;
+
+    if (typeof globalThis.Blob !== "undefined") {
+        blob = new Blob([code], { type: mime_type });
+    } else {
+        // Backwards-compatibility
+        const BlobBuilder = globalThis.BlobBuilder
+            || globalThis.BlobBuilder
+            || globalThis.WebKitBlobBuilder
+            || globalThis.MozBlobBuilder;
+
+        if (BlobBuilder !== undefined) {
+            blob = new BlobBuilder();
+            blob.append(code);
+            blob = blob.getBlob();
+        } else {
+            throw new Error(`No BlobBuilder interface supported in current context`);
+        }
+
+    }
+
+
+    return blob;
+}

package/src/core/codegen/codeToURL.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {string} code
+ * @param {string} [mime_type]
+ * @return {string}
+ */
+export function codeToURL(code: string, mime_type?: string): string;
+//# sourceMappingURL=codeToURL.d.ts.map

package/src/core/codegen/codeToURL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeToURL.d.ts","sourceRoot":"","sources":["../../../../src/core/codegen/codeToURL.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,gCAJW,MAAM,cACN,MAAM,GACL,MAAM,CAcjB"}

package/src/core/codegen/codeToURL.js

@@ -0,0 +1,22 @@
+import { assert } from "../assert.js";
+import { codeToBlob } from "./codeToBlob.js";
+
+/**
+ *
+ * @param {string} code
+ * @param {string} [mime_type]
+ * @return {string}
+ */
+export function codeToURL(code, mime_type = 'application/javascript') {
+    assert.isString(code, 'code');
+    assert.isString(mime_type, 'mime_type');
+
+    const blob = codeToBlob(code, mime_type);
+
+    if (blob !== undefined && URL.createObjectURL !== undefined) {
+        return URL.createObjectURL(blob);
+    } else {
+        // build data URL in a slowest way possible
+        return `data:${mime_type},${encodeURIComponent(code)}`;
+    }
+}

package/src/core/collection/array/arrayQuickSort.d.ts

@@ -9,13 +9,4 @@
  * @param {*} [swap_context]
  */
 export function arrayQuickSort<T>(data: ArrayLike<number> | Uint32Array | T[], score_function: (arg0: T) => number, score_function_context: any, start: number, end: number, swap_operator?: (arg0: T[], arg1: number, arg2: number) => any, swap_context?: any): void;
-/**
- * @template T
- * @param {T[]} data
- * @param {function(T,T):number} compare_function
- * @param {*} compare_function_context
- * @param {number} start
- * @param {number} end
- */
-export function array_quick_sort_by_comparator<T>(data: T[], compare_function: (arg0: T, arg1: T) => number, compare_function_context: any, start: number, end: number): void;
 //# sourceMappingURL=arrayQuickSort.d.ts.map

package/src/core/collection/array/arrayQuickSort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arrayQuickSort.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/arrayQuickSort.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,4GAPuB,MAAM,sCAElB,MAAM,OACN,MAAM,oCACO,MAAM,QAAE,MAAM,oCAiErC;AAED;;;;;;;GAOG;AACH,qGALyB,MAAM,wCAEpB,MAAM,OACN,MAAM,QAkEhB"}
+{"version":3,"file":"arrayQuickSort.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/arrayQuickSort.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,4GAPuB,MAAM,sCAElB,MAAM,OACN,MAAM,oCACO,MAAM,QAAE,MAAM,oCAiErC"}

package/src/core/collection/array/arrayQuickSort.js

@@ -76,76 +76,3 @@ export function arrayQuickSort(
     }
 }
 
-/**
- * @template T
- * @param {T[]} data
- * @param {function(T,T):number} compare_function
- * @param {*} compare_function_context
- * @param {number} start
- * @param {number} end
- */
-export function array_quick_sort_by_comparator(
-    data,
-    compare_function, compare_function_context,
-    start, end
-) {
-    if (start >= end) {
-        // section of 0 size, nothing to sort
-        return;
-    }
-
-    let stackPointer = 2;
-    let i, j;
-
-    stack[0] = start;
-    stack[1] = end;
-
-    while (stackPointer > 0) {
-        stackPointer -= 2;
-
-        const right = stack[stackPointer + 1];
-        const left = stack[stackPointer];
-
-        i = left;
-        j = right;
-
-        const pivotIndex = (left + right) >> 1;
-
-        const pivot = data[pivotIndex];
-
-        /* partition */
-        while (i <= j) {
-            while (compare_function.call(compare_function_context, data[i], pivot) < 0) {
-                i++;
-            }
-
-            while (compare_function.call(compare_function_context, data[j], pivot) > 0) {
-                j--;
-            }
-
-            if (i <= j) {
-
-                if (i !== j) {
-                    //do swap
-                    const tmp = data[i];
-                    data[i] = data[j];
-                    data[j] = tmp;
-
-                }
-
-                i++;
-                j--;
-            }
-        }
-
-        /* recursion */
-        if (left < j) {
-            stack[stackPointer++] = left;
-            stack[stackPointer++] = j;
-        }
-        if (i < right) {
-            stack[stackPointer++] = i;
-            stack[stackPointer++] = right;
-        }
-    }
-}

package/src/core/collection/array/array_quick_sort_by_comparator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @template T
+ * @param {T[]|Uint32Array} data
+ * @param {function(T,T):number} compare_function
+ * @param {*} compare_function_context
+ * @param {number} start
+ * @param {number} end
+ */
+export function array_quick_sort_by_comparator<T>(data: Uint32Array | T[], compare_function: (arg0: T, arg1: T) => number, compare_function_context: any, start: number, end: number): void;
+//# sourceMappingURL=array_quick_sort_by_comparator.d.ts.map

package/src/core/collection/array/array_quick_sort_by_comparator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_quick_sort_by_comparator.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_quick_sort_by_comparator.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,mHALyB,MAAM,wCAEpB,MAAM,OACN,MAAM,QAkEhB"}

package/src/core/collection/array/array_quick_sort_by_comparator.js

@@ -0,0 +1,75 @@
+const stack = [];
+
+/**
+ * @template T
+ * @param {T[]|Uint32Array} data
+ * @param {function(T,T):number} compare_function
+ * @param {*} compare_function_context
+ * @param {number} start
+ * @param {number} end
+ */
+export function array_quick_sort_by_comparator(
+    data,
+    compare_function, compare_function_context,
+    start, end
+) {
+    if (start >= end) {
+        // section of 0 size, nothing to sort
+        return;
+    }
+
+    let stackPointer = 2;
+    let i, j;
+
+    stack[0] = start;
+    stack[1] = end;
+
+    while (stackPointer > 0) {
+        stackPointer -= 2;
+
+        const right = stack[stackPointer + 1];
+        const left = stack[stackPointer];
+
+        i = left;
+        j = right;
+
+        const pivotIndex = (left + right) >> 1;
+
+        const pivot = data[pivotIndex];
+
+        /* partition */
+        while (i <= j) {
+            while (compare_function.call(compare_function_context, data[i], pivot) < 0) {
+                i++;
+            }
+
+            while (compare_function.call(compare_function_context, data[j], pivot) > 0) {
+                j--;
+            }
+
+            if (i <= j) {
+
+                if (i !== j) {
+                    //do swap
+                    const tmp = data[i];
+                    data[i] = data[j];
+                    data[j] = tmp;
+
+                }
+
+                i++;
+                j--;
+            }
+        }
+
+        /* recursion */
+        if (left < j) {
+            stack[stackPointer++] = left;
+            stack[stackPointer++] = j;
+        }
+        if (i < right) {
+            stack[stackPointer++] = i;
+            stack[stackPointer++] = right;
+        }
+    }
+}

package/src/core/collection/array/array_quick_sort_by_lookup.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {number[]|Uint32Array} data
+ * @param {number[]|Uint32Array} lookup
+ * @param {number} start
+ * @param {number} end
+ */
+export function array_quick_sort_by_lookup(data: number[] | Uint32Array, lookup: number[] | Uint32Array, start: number, end: number): void;
+//# sourceMappingURL=array_quick_sort_by_lookup.d.ts.map

package/src/core/collection/array/array_quick_sort_by_lookup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_quick_sort_by_lookup.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_quick_sort_by_lookup.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,iDALW,MAAM,EAAE,GAAC,WAAW,UACpB,MAAM,EAAE,GAAC,WAAW,SACpB,MAAM,OACN,MAAM,QAqEhB"}

package/src/core/collection/array/array_quick_sort_by_lookup.js

@@ -0,0 +1,78 @@
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../SCRATCH_UINT32_TRAVERSAL_STACK.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+/**
+ * @param {number[]|Uint32Array} data
+ * @param {number[]|Uint32Array} lookup
+ * @param {number} start
+ * @param {number} end
+ */
+export function array_quick_sort_by_lookup(
+    data,
+    lookup,
+    start, end
+) {
+    if (start >= end) {
+        // section of 0 size, nothing to sort
+        return;
+    }
+
+    const stack_frame = start.pointer;
+    let stackPointer = stack_frame;
+
+    let i, j;
+
+    stack[stackPointer++] = start;
+    stack[stackPointer++] = end;
+
+    while (stackPointer > stack_frame) {
+        stackPointer -= 2;
+
+        const right = stack[stackPointer + 1];
+        const left = stack[stackPointer];
+
+        i = left;
+        j = right;
+
+        const pivotIndex = (left + right) >> 1;
+
+        const pivot = data[pivotIndex];
+        const pivot_score = lookup[pivot];
+
+        /* partition */
+        while (i <= j) {
+            while (lookup[data[i]] < pivot_score) {
+                i++;
+            }
+
+            while (lookup[data[j]] > pivot_score) {
+                j--;
+            }
+
+            if (i <= j) {
+
+                if (i !== j) {
+                    //do swap
+                    const tmp = data[i];
+                    data[i] = data[j];
+                    data[j] = tmp;
+
+                }
+
+                i++;
+                j--;
+            }
+        }
+
+        /* recursion */
+        if (left < j) {
+            stack[stackPointer++] = left;
+            stack[stackPointer++] = j;
+        }
+        if (i < right) {
+            stack[stackPointer++] = i;
+            stack[stackPointer++] = right;
+        }
+    }
+}

package/src/core/collection/array/array_shuffle.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Randomly re-orders items in-place
+ * @template T
+ * @param {function} random
+ * @param {T[]} array
+ */
+export function array_shuffle<T>(random: Function, array: T[]): void;
+//# sourceMappingURL=array_shuffle.d.ts.map

package/src/core/collection/array/array_shuffle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_shuffle.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_shuffle.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,qEAYC"}