@woosh/meep-engine 2.47.3 → 2.47.10

package/build/meep.module.js

@@ -49631,7 +49631,7 @@ function arraySwapElements(array, index0, index1) {
     array[index1] = t;
 }
 
-const stack$8 = [];
+const stack$b = [];
 
 /**
  * @template T
@@ -49652,14 +49652,14 @@ function arrayQuickSort(data, score_function, score_function_context, start, end
     let stackPointer = 2;
     let i, j;
 
-    stack$8[0] = start;
-    stack$8[1] = end;
+    stack$b[0] = start;
+    stack$b[1] = end;
 
     while (stackPointer > 0) {
         stackPointer -= 2;
 
-        const right = stack$8[stackPointer + 1];
-        const left = stack$8[stackPointer];
+        const right = stack$b[stackPointer + 1];
+        const left = stack$b[stackPointer];
 
         i = left;
         j = right;
@@ -49692,12 +49692,12 @@ function arrayQuickSort(data, score_function, score_function_context, start, end
 
         /* recursion */
         if (left < j) {
-            stack$8[stackPointer++] = left;
-            stack$8[stackPointer++] = j;
+            stack$b[stackPointer++] = left;
+            stack$b[stackPointer++] = j;
         }
         if (i < right) {
-            stack$8[stackPointer++] = i;
-            stack$8[stackPointer++] = right;
+            stack$b[stackPointer++] = i;
+            stack$b[stackPointer++] = right;
         }
     }
 }
@@ -49719,14 +49719,14 @@ function array_quick_sort_by_comparator(data, compare_function, compare_function
     let stackPointer = 2;
     let i, j;
 
-    stack$8[0] = start;
-    stack$8[1] = end;
+    stack$b[0] = start;
+    stack$b[1] = end;
 
     while (stackPointer > 0) {
         stackPointer -= 2;
 
-        const right = stack$8[stackPointer + 1];
-        const left = stack$8[stackPointer];
+        const right = stack$b[stackPointer + 1];
+        const left = stack$b[stackPointer];
 
         i = left;
         j = right;
@@ -49762,12 +49762,12 @@ function array_quick_sort_by_comparator(data, compare_function, compare_function
 
         /* recursion */
         if (left < j) {
-            stack$8[stackPointer++] = left;
-            stack$8[stackPointer++] = j;
+            stack$b[stackPointer++] = left;
+            stack$b[stackPointer++] = j;
         }
         if (i < right) {
-            stack$8[stackPointer++] = i;
-            stack$8[stackPointer++] = right;
+            stack$b[stackPointer++] = i;
+            stack$b[stackPointer++] = right;
         }
     }
 }
@@ -49872,7 +49872,7 @@ function mortonEncode_magicbits(x, y, z) {
  * @param {number} _z1
  * @returns {number}
  */
-function aabb3_computeDistanceAbovePlane_max(
+function aabb3_compute_distance_above_plane_max(
     plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
     _x0, _y0, _z0,
     _x1, _y1, _z1
@@ -49920,7 +49920,7 @@ function v3_distance_above_plane(
  * @param {number} _z1
  * @returns {number}
  */
-function computeAABB3PlaneSide(
+function aabb3_compute_plane_side(
     plane_normal_x,
     plane_normal_y,
     plane_normal_z,
@@ -50052,16 +50052,15 @@ function aabb3_intersects_frustum_degree(
 ) {
 
     let result = 2;
-    let i = 0;
 
-    for (; i < 24; i += 4) {
+    for (let i = 0; i < 24; i += 4) {
 
         const p_x = frustum[i];
         const p_y = frustum[i + 1];
         const p_z = frustum[i + 2];
         const p_w = frustum[i + 3];
 
-        const plane_side = computeAABB3PlaneSide(
+        const plane_side = aabb3_compute_plane_side(
             p_x, p_y, p_z, p_w,
             x0, y0, z0, x1, y1, z1
         );
@@ -50070,6 +50069,7 @@ function aabb3_intersects_frustum_degree(
             // completely outside
             return 0;
         } else if (plane_side === 0) {
+            // partially inside - plane intersects AABB
             result = 1;
         }
     }
@@ -50082,7 +50082,7 @@ function aabb3_intersects_frustum_degree(
  * @param {Number} val
  * @returns {number}
  */
-function fabsf(val) {
+function fabsf$1(val) {
     return val >= 0 ? val : -val;
 }
 
@@ -50128,22 +50128,22 @@ function aabb3_intersects_line_segment(
     boxExtentsX = (x1 - x0) / 2;
     centerX = x0 + boxExtentsX;
     diffX = (0.5 * (endX + startX)) - centerX;
-    a = fabsf(dirX);
-    if (fabsf(diffX) > boxExtentsX + a) return false;
+    a = fabsf$1(dirX);
+    if (fabsf$1(diffX) > boxExtentsX + a) return false;
     //
     dirY = 0.5 * (endY - startY);
     boxExtentsY = (y1 - y0) / 2;
     centerY = y0 + boxExtentsY;
     diffY = (0.5 * (endY + startY)) - centerY;
-    b = fabsf(dirY);
-    if (fabsf(diffY) > boxExtentsY + b) return false;
+    b = fabsf$1(dirY);
+    if (fabsf$1(diffY) > boxExtentsY + b) return false;
     //
     dirZ = 0.5 * (endZ - startZ);
     boxExtentsZ = (z1 - z0) / 2;
     centerZ = z0 + boxExtentsZ;
     diffZ = (0.5 * (endZ + startZ)) - centerZ;
-    c = fabsf(dirZ);
-    if (fabsf(diffZ) > boxExtentsZ + c) return false;
+    c = fabsf$1(dirZ);
+    if (fabsf$1(diffZ) > boxExtentsZ + c) return false;
 
     //Dir.y = 0.5f * (segment.mP1.y - segment.mP0.y);
     //BoxExtents.y = aabb.GetExtents(1);
@@ -50153,15 +50153,17 @@ function aabb3_intersects_line_segment(
 
     let f;
     f = dirY * diffZ - dirZ * diffY;
-    if (fabsf(f) > boxExtentsY * c + boxExtentsZ * b) return false;
+    if (fabsf$1(f) > boxExtentsY * c + boxExtentsZ * b) return false;
     f = dirZ * diffX - dirX * diffZ;
-    if (fabsf(f) > boxExtentsX * c + boxExtentsZ * a) return false;
+    if (fabsf$1(f) > boxExtentsX * c + boxExtentsZ * a) return false;
     f = dirX * diffY - dirY * diffX;
-    if (fabsf(f) > boxExtentsX * b + boxExtentsY * a) return false;
+    if (fabsf$1(f) > boxExtentsX * b + boxExtentsY * a) return false;
 
     return true;
 }
 
+const fabsf = Math.abs;
+
 /**
  * NOTES:
  *      https://web.archive.org/web/20090803054252/http://tog.acm.org/resources/GraphicsGems/gems/RayBox.c
@@ -50174,86 +50176,77 @@ function aabb3_intersects_line_segment(
  * @param {number} x1
  * @param {number} y1
  * @param {number} z1
- * @param {number} oX
- * @param {number} oY
- * @param {number} oZ
- * @param {number} dirX
- * @param {number} dirY
- * @param {number} dirZ
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
  * @returns {boolean}
  */
 function aabb3_intersects_ray(
     x0, y0, z0,
     x1, y1, z1,
-    oX, oY, oZ,
-    dirX, dirY, dirZ
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
 ) {
 
     // Z Projection
-    const boxExtentsX = (x1 - x0) * 0.5;
+    const extents_x = (x1 - x0) * 0.5;
 
-    const centerX = x0 + boxExtentsX;
+    const center_x = x0 + extents_x;
 
-    const diffX = oX - centerX;
+    const diff_x = origin_x - center_x;
 
 
-    if (diffX * dirX >= 0.0 && fabsf(diffX) > boxExtentsX) {
+    if (diff_x * direction_x >= 0.0 && fabsf(diff_x) > extents_x) {
         return false;
     }
 
     // Y projection
-    const boxExtentsY = (y1 - y0) * 0.5;
+    const extents_y = (y1 - y0) * 0.5;
 
-    const centerY = y0 + boxExtentsY;
+    const center_y = y0 + extents_y;
 
-    const diffY = oY - centerY;
+    const diff_y = origin_y - center_y;
 
 
-    if (diffY * dirY >= 0.0 && fabsf(diffY) > boxExtentsY) {
+    if (diff_y * direction_y >= 0.0 && fabsf(diff_y) > extents_y) {
         return false;
     }
 
     // Z projection
-    const boxExtentsZ = (z1 - z0) * 0.5;
+    const extents_z = (z1 - z0) * 0.5;
 
-    const centerZ = z0 + boxExtentsZ;
+    const center_z = z0 + extents_z;
 
-    const diffZ = oZ - centerZ;
+    const diff_z = origin_z - center_z;
 
 
-    if (diffZ * dirZ >= 0.0 && fabsf(diffZ) > boxExtentsZ) {
+    if (diff_z * direction_z >= 0.0 && fabsf(diff_z) > extents_z) {
         return false;
     }
 
-    //Dir.y = 0.5f * (segment.mP1.y - segment.mP0.y);
-    //BoxExtents.y = aabb.GetExtents(1);
-    //Diff.y = (0.5f * (segment.mP1.y + segment.mP0.y)) - aabb.GetCenter(1);
-    //b = fabsf(Dir.y);
-    //if(fabsf(Diff.y)>BoxExtents.y + b)	return false;
+    const abs_direction_y = fabsf(direction_y);
+    const abs_direction_z = fabsf(direction_z);
 
-    const b = fabsf(dirY);
-    const c = fabsf(dirZ);
-    const a = fabsf(dirX);
+    const f0 = fabsf(direction_y * diff_z - direction_z * diff_y);
 
-    const f0 = dirY * diffZ - dirZ * diffY;
-
-    if (fabsf(f0) > boxExtentsY * c + boxExtentsZ * b) {
+    if (f0 > extents_y * abs_direction_z + extents_z * abs_direction_y) {
         return false;
     }
 
-    const f1 = dirZ * diffX - dirX * diffZ;
+    const abs_direction_x = fabsf(direction_x);
 
-    if (fabsf(f1) > boxExtentsX * c + boxExtentsZ * a) {
-        return false;
-    }
-
-    const f2 = dirX * diffY - dirY * diffX;
+    const f1 = fabsf(direction_z * diff_x - direction_x * diff_z);
 
-    if (fabsf(f2) > boxExtentsX * b + boxExtentsY * a) {
+    if (f1 > extents_x * abs_direction_z + extents_z * abs_direction_x) {
         return false;
     }
 
-    return true;
+    const f2 = fabsf(direction_x * diff_y - direction_y * diff_x);
+
+    return f2 <= extents_x * abs_direction_y + extents_y * abs_direction_x;
 }
 
 /**
@@ -50292,7 +50285,7 @@ function aabb3_intersects_frustum_array(x0, y0, z0, x1, y1, z1, frustum) {
         const plane_z = frustum[i + 2];
         const plane_w = frustum[i + 3];
 
-        const plane_distance = aabb3_computeDistanceAbovePlane_max(
+        const plane_distance = aabb3_compute_distance_above_plane_max(
             plane_x, plane_y, plane_z, plane_w,
             x0, y0, z0,
             x1, y1, z1
@@ -50381,6 +50374,25 @@ function aabb3_signed_distance_sqr_to_point(x0, y0, z0, x1, y1, z1, point_x, poi
     }
 }
 
+//
+
+/**
+ *
+ * @param {ArrayLike<number>|number[]|AABB3} aabb
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {boolean}
+ */
+function aabb3_array_contains_point(aabb, x, y, z) {
+    return x >= aabb[0]
+        && x <= aabb[3]
+        && y >= aabb[1]
+        && y <= aabb[4]
+        && z >= aabb[2]
+        && z <= aabb[5];
+}
+
 /**
  * Created by Alex on 16/11/2014.
  */
@@ -50472,19 +50484,14 @@ class AABB3 {
     }
 
     /**
-     *
+     * @deprecated use {@link aabb3_array_contains_point} directly
      * @param {number} x
      * @param {number} y
      * @param {number} z
      * @returns {boolean}
      */
     containsPoint(x, y, z) {
-        return x >= this.x0
-            && x <= this.x1
-            && y >= this.y0
-            && y <= this.y1
-            && z >= this.z0
-            && z <= this.z1;
+        return aabb3_array_contains_point(this, x, y, z);
     }
 
     /**
@@ -50496,15 +50503,9 @@ class AABB3 {
      * @returns {boolean}
      */
     containsPointWithTolerance(x, y, z, tolerance) {
-        if (
-            (x + tolerance) < this.x0 || (x - tolerance) > this.x1
+        return !((x + tolerance) < this.x0 || (x - tolerance) > this.x1
             || (y + tolerance) < this.y0 || (y - tolerance) > this.y1
-            || (z + tolerance) < this.z0 || (z - tolerance) > this.z1
-        ) {
-            return false;
-        }
-
-        return true;
+            || (z + tolerance) < this.z0 || (z - tolerance) > this.z1);
     }
 
     computeMortonCode() {
@@ -50556,6 +50557,13 @@ class AABB3 {
      * @param {Number} z1
      */
     setBounds(x0, y0, z0, x1, y1, z1) {
+        assert.notNaN(x0, 'x0');
+        assert.notNaN(y0, 'y0');
+        assert.notNaN(z0, 'z0');
+        assert.notNaN(x1, 'x1');
+        assert.notNaN(y1, 'y1');
+        assert.notNaN(z1, 'z1');
+
         /**
          *
          * @type {number}
@@ -51082,13 +51090,15 @@ class AABB3 {
     readFromArray(source, offset = 0) {
         assert.isNonNegativeInteger(offset, 'offset');
 
-        this.x0 = source[offset];
-        this.y0 = source[offset + 1];
-        this.z0 = source[offset + 2];
+        const _x0 = source[offset];
+        const _y0 = source[offset + 1];
+        const _z0 = source[offset + 2];
+
+        const _x1 = source[offset + 3];
+        const _y1 = source[offset + 4];
+        const _z1 = source[offset + 5];
 
-        this.x1 = source[offset + 3];
-        this.y1 = source[offset + 4];
-        this.z1 = source[offset + 5];
+        this.setBounds(_x0, _y0, _z0, _x1, _y1, _z1);
     }
 
     /**
@@ -51098,7 +51108,7 @@ class AABB3 {
     computePlaneSide(plane) {
         const normal = plane.normal;
 
-        return computeAABB3PlaneSide(
+        return aabb3_compute_plane_side(
             normal.x, normal.y, normal.z, plane.constant,
             this.x0, this.y0, this.z0,
             this.x1, this.y1, this.z1
@@ -51114,7 +51124,7 @@ class AABB3 {
      * @returns {number}
      */
     computeDistanceAbovePlane(normal_x, normal_y, normal_z, offset) {
-        return aabb3_computeDistanceAbovePlane_max(
+        return aabb3_compute_distance_above_plane_max(
             normal_x, normal_y, normal_z, offset,
             this.x0, this.y0, this.z0,
             this.x1, this.y1, this.z1
@@ -51599,7 +51609,7 @@ class BVHVisitor {
     }
 }
 
-const stack$7 = [];
+const stack$a = [];
 let stackPointer$3 = 0;
 
 /**
@@ -51612,11 +51622,11 @@ function traverseBinaryNodeUsingVisitor(node, visitor) {
 
     const stackOffset = stackPointer$3;
 
-    stack$7[stackPointer$3++] = node;
+    stack$a[stackPointer$3++] = node;
 
     while (stackPointer$3-- > stackOffset) {
 
-        n = stack$7[stackPointer$3];
+        n = stack$a[stackPointer$3];
 
         if (n.isBinaryNode) {
             const traverseDeeper = visitor.visitBinary(n);
@@ -51627,7 +51637,7 @@ function traverseBinaryNodeUsingVisitor(node, visitor) {
 
                     // has a LEFT child
 
-                    stack$7[stackPointer$3++] = n.left;
+                    stack$a[stackPointer$3++] = n.left;
 
                 }
 
@@ -51635,7 +51645,7 @@ function traverseBinaryNodeUsingVisitor(node, visitor) {
 
                     // has a RIGHT child
 
-                    stack$7[stackPointer$3++] = n.right;
+                    stack$a[stackPointer$3++] = n.right;
 
                 }
 
@@ -51684,7 +51694,7 @@ function intersects1D(a0, a1, b0, b1) {
  * @param {number} bz1
  * @returns {boolean}
  */
-function aabb3_intersect_aabb3(
+function aabb3_intersects_aabb3(
     ax0, ay0, az0,
     ax1, ay1, az1,
     bx0, by0, bz0,
@@ -51760,7 +51770,7 @@ let stackPointer$2 = 0;
  *
  * @type {Node[]}
  */
-const stack$6 = [];
+const stack$9 = [];
 
 class BinaryNode extends Node {
     constructor() {
@@ -51810,22 +51820,22 @@ class BinaryNode extends Node {
 
         const stackOffset = stackPointer$2;
 
-        stack$6[stackPointer$2++] = this;
+        stack$9[stackPointer$2++] = this;
         let n;
         while (stackPointer$2-- > stackOffset) {
 
             visitCount++;
 
-            n = stack$6[stackPointer$2];
+            n = stack$9[stackPointer$2];
 
             const traverseDeeper = visitor.call(thisArg, n);
 
             if (traverseDeeper !== false && n.isBinaryNode) {
                 if (n.right !== null) {
-                    stack$6[stackPointer$2++] = n.right;
+                    stack$9[stackPointer$2++] = n.right;
                 }
                 if (n.left !== null) {
-                    stack$6[stackPointer$2++] = n.left;
+                    stack$9[stackPointer$2++] = n.left;
                 }
             }
         }
@@ -51846,7 +51856,7 @@ class BinaryNode extends Node {
 
         const stackOffset = stackPointer$2;
 
-        stack$6[stackPointer$2++] = this;
+        stack$9[stackPointer$2++] = this;
 
         let n;
 
@@ -51854,17 +51864,17 @@ class BinaryNode extends Node {
 
             visitCount++;
 
-            n = stack$6[stackPointer$2];
+            n = stack$9[stackPointer$2];
 
             if (n.isLeafNode) {
                 visitor.call(thisArg, n);
             } else {
                 //a binary node
                 if (n.right !== null) {
-                    stack$6[stackPointer$2++] = n.right;
+                    stack$9[stackPointer$2++] = n.right;
                 }
                 if (n.left !== null) {
-                    stack$6[stackPointer$2++] = n.left;
+                    stack$9[stackPointer$2++] = n.left;
                 }
             }
         }
@@ -52120,13 +52130,15 @@ class BinaryNode extends Node {
         const a = this.left;
         const b = this.right;
 
-        this.x0 = min2(a.x0, b.x0);
-        this.y0 = min2(a.y0, b.y0);
-        this.z0 = min2(a.z0, b.z0);
+        const x0 = min2(a.x0, b.x0);
+        const y0 = min2(a.y0, b.y0);
+        const z0 = min2(a.z0, b.z0);
+
+        const x1 = max2(a.x1, b.x1);
+        const y1 = max2(a.y1, b.y1);
+        const z1 = max2(a.z1, b.z1);
 
-        this.x1 = max2(a.x1, b.x1);
-        this.y1 = max2(a.y1, b.y1);
-        this.z1 = max2(a.z1, b.z1);
+        this.setBounds(x0, y0, z0, x1, y1, z1);
     }
 
     bubbleRefit() {
@@ -52441,15 +52453,15 @@ class BinaryNode extends Node {
     requestLeafIntersectionsAABB3(result, x0, y0, z0, x1, y1, z1) {
         const startOffset = stackPointer$2;
 
-        stack$6[stackPointer$2++] = this;
+        stack$9[stackPointer$2++] = this;
 
         let count = 0;
 
         while (stackPointer$2 > startOffset) {
             stackPointer$2--;
-            const node = stack$6[stackPointer$2];
+            const node = stack$9[stackPointer$2];
 
-            if (!aabb3_intersect_aabb3(
+            if (!aabb3_intersects_aabb3(
                 x0, y0, z0, x1, y1, z1,
                 node.x0, node.y0, node.z0, node.x1, node.y1, node.z1
             )) {
@@ -52464,12 +52476,12 @@ class BinaryNode extends Node {
             } else {
                 const left = node.left;
                 if (left !== null) {
-                    stack$6[stackPointer$2++] = left;
+                    stack$9[stackPointer$2++] = left;
                 }
 
                 const right = node.right;
                 if (right !== null) {
-                    stack$6[stackPointer$2++] = right;
+                    stack$9[stackPointer$2++] = right;
                 }
             }
         }
@@ -55936,14 +55948,14 @@ class IndexedBinaryBVH {
 
         const stackOffset = stackPointer$1;
 
-        stack$5[stackPointer$1++] = startIndex;
+        stack$8[stackPointer$1++] = startIndex;
 
         const nodeThreshold = this.binaryNodeCount * 6;
         const endAddress = this.boxCount * 6;
 
         while (stackPointer$1-- > stackOffset) {
 
-            const index = stack$5[stackPointer$1];
+            const index = stack$8[stackPointer$1];
 
             const address = index * 6;
 
@@ -55959,7 +55971,7 @@ class IndexedBinaryBVH {
                 //right
                 if (rightAddress < endAddress) {
                     if (rightAddress < nodeThreshold) {
-                        stack$5[stackPointer$1++] = rightIndex;
+                        stack$8[stackPointer$1++] = rightIndex;
                     } else {
                         visitor.visit(rightAddress, NodeType.LEAF);
                     }
@@ -55968,7 +55980,7 @@ class IndexedBinaryBVH {
                 //left
                 if (leftAddress < endAddress) {
                     if (leftAddress < nodeThreshold) {
-                        stack$5[stackPointer$1++] = leftIndex;
+                        stack$8[stackPointer$1++] = leftIndex;
                     } else {
                         visitor.visit(leftAddress, NodeType.LEAF);
                     }
@@ -56144,7 +56156,7 @@ function binaryNodeRefit(array, binaryNode, childNode0, childNode1) {
 }
 
 
-const stack$5 = [];
+const stack$8 = [];
 let stackPointer$1 = 0;
 
 const rayLeafIntersectionVisitor = new RayLeafIntersectionVisitor();
@@ -56154,7 +56166,16 @@ const rayLeafIntersectionVisitor = new RayLeafIntersectionVisitor();
  */
 class SurfacePoint3 {
     constructor() {
+        /**
+         * @readonly
+         * @type {Vector3}
+         */
         this.normal = new Vector3$1(0, 1, 0);
+
+        /**
+         * @readonly
+         * @type {Vector3}
+         */
         this.position = new Vector3$1(0, 0, 0);
 
         /**
@@ -56165,6 +56186,30 @@ class SurfacePoint3 {
         this.index = -1;
     }
 
+    get 0() {
+        return this.position.x;
+    }
+
+    get 1() {
+        return this.position.y;
+    }
+
+    get 2() {
+        return this.position.z;
+    }
+
+    get 3() {
+        return this.normal.x;
+    }
+
+    get 4() {
+        return this.normal.y;
+    }
+
+    get 5() {
+        return this.normal.z;
+    }
+
     /**
      *
      * @param {number[]|mat4|Float32Array} m
@@ -56214,13 +56259,35 @@ class SurfacePoint3 {
     }
 
     /**
-     *
+     * @deprecated use {@link applyMatrix4} instead
      * @param {THREE.Matrix4} matrix4
      */
     applyMatrix4_three(matrix4) {
+        console.warn('applyMatrix4_three is deprecated, use applyMatrix4 instead');
+
         this.applyMatrix4(matrix4.elements);
     }
 
+    /**
+     *
+     * @param {number[]|ArrayLike<number>|Float32Array} array
+     * @param {number} [offset=0]
+     */
+    fromArray(array, offset = 0) {
+        this.position.readFromArray(array, offset);
+        this.normal.readFromArray(array, offset + 3);
+    }
+
+    /**
+     *
+     * @param {number[]|ArrayLike<number>|Float32Array} array
+     * @param {number} [offset=0]
+     */
+    toArray(array, offset = 0) {
+        this.position.writeToArray(array, offset);
+        this.normal.writeToArray(array, offset + 3);
+    }
+
     /**
      *
      * @param {SurfacePoint3} other
@@ -57837,16 +57904,24 @@ function hex2dec(v) {
 /**
  *
  * @param {string} hex
- * @returns {{r: Number, g: Number, b: Number}} rgb
+ * @returns {{r: number, g: number, b: number, a:number}} rgb
  */
 function parseHex(hex) {
 
 
-    return {
+    const result = {
         r: hex2dec(hex.slice(1, 3)),
         g: hex2dec(hex.slice(3, 5)),
-        b: hex2dec(hex.slice(5))
+        b: hex2dec(hex.slice(5, 7))
     };
+
+    if (hex.length > 7) {
+        result.a = hex2dec(hex.slice(7, 9));
+    }else {
+        result.a = 1;
+    }
+
+    return result;
 }
 
 /**
@@ -57855,7 +57930,7 @@ function parseHex(hex) {
 
 
 const rgbRegEx = /rgb\(\s*([0-9]+),\s*([0-9]+),\s*([0-9]+)\s*\)/;
-const rgbaRegEx = /rgba\(\s*([0-9]+),\s*([0-9]+),\s*([0-9]+),\s*([0-9]+(?:\.[0-9]*)?)\s*\)/;
+const rgbaRegEx = /rgba\(\s*([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?)\s*\)/;
 const hsvRegEx = /hsv\(([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?)\)/;
 
 /**
@@ -57884,10 +57959,10 @@ function parseColor(c) {
 
         } else if ((match = cL.match(rgbaRegEx)) !== null) {
 
-            r = parseInt(match[1]);
-            g = parseInt(match[2]);
-            b = parseInt(match[3]);
-            a = parseInt(match[4]);
+            r = parseFloat(match[1]);
+            g = parseFloat(match[2]);
+            b = parseFloat(match[3]);
+            a = parseFloat(match[4]);
 
         } else if ((match = cL.match(hsvRegEx)) !== null) {
 
@@ -57908,6 +57983,8 @@ function parseColor(c) {
             r = rgb.r;
             g = rgb.g;
             b = rgb.b;
+            a = rgb.a;
+
 
         } else {
             throw new Error(`Failed to decode color string '${c}' `);
@@ -58112,7 +58189,7 @@ class Color {
 
         /**
          * @readonly
-         * @type {Signal<number,number,number,number,number,number>}
+         * @type {Signal<number,number,number,number,number,number,number,number>}
          */
         this.onChanged = new Signal();
     }
@@ -58188,19 +58265,34 @@ class Color {
      * @param {number} b
      */
     setRGB(r, g, b) {
+
+        this.set(r, g, b, this.a);
+    }
+
+    /**
+     *
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     * @param {number} a
+     */
+    set(r, g, b, a) {
         assert.isNumber(r, 'r');
         assert.isNumber(g, 'g');
         assert.isNumber(b, 'b');
+        assert.isNumber(a, 'a');
 
         const _r = this.r;
         const _g = this.g;
         const _b = this.b;
+        const _a = this.a;
 
         this.r = r;
         this.g = g;
         this.b = b;
+        this.a = a;
 
-        this.onChanged.send6(r, g, b, _r, _g, _b);
+        this.onChanged.send8(r, g, b, a, _r, _g, _b, _a);
     }
 
     /**
@@ -58464,7 +58556,10 @@ class Color {
      * @param {Color} other
      */
     equals(other) {
-        return this.r === other.r && this.g === other.g && this.b === other.b;
+        return this.r === other.r
+            && this.g === other.g
+            && this.b === other.b
+            && this.a === other.a;
     }
 
     /**
@@ -58500,15 +58595,17 @@ class Color {
         );
     }
 
-    fromJSON({ r, g, b }) {
+    fromJSON({ r, g, b, a = 1 }) {
         this.setRGB(r, g, b);
+        this.a = a;
     }
 
     toJSON() {
         return {
             r: this.r,
             g: this.g,
-            b: this.b
+            b: this.b,
+            a: this.a
         };
     }
 
@@ -58517,6 +58614,7 @@ class Color {
         yield this.r;
         yield this.g;
         yield this.b;
+        yield this.a;
 
     }
 
@@ -58529,6 +58627,7 @@ class Color {
         destination[destination_offset] = this.r;
         destination[destination_offset + 1] = this.g;
         destination[destination_offset + 2] = this.b;
+        destination[destination_offset + 3] = this.a;
     }
 
     /**
@@ -58539,6 +58638,7 @@ class Color {
         buffer.writeFloat32(this.r);
         buffer.writeFloat32(this.g);
         buffer.writeFloat32(this.b);
+        buffer.writeFloat32(this.a);
     }
 
     /**
@@ -58549,8 +58649,10 @@ class Color {
         const r = buffer.readFloat32();
         const g = buffer.readFloat32();
         const b = buffer.readFloat32();
+        const a = buffer.readFloat32();
 
         this.setRGB(r, g, b);
+        this.a = a;
     }
 
     /**
@@ -65390,106 +65492,6 @@ WorkerBuilder.prototype.build = function () {
     return proxy;
 };
 
-/**
- *
- * @param {Sampler2D} sampler
- * @param {number} [channel=0]
- * @returns {undefined|{x: number, index:number, y: number, value: number}}
- */
-function sampler2d_channel_compute_max(sampler, channel=0){
-    const itemSize = sampler.itemSize;
-
-    assert.isNumber(channel, "channel");
-    assert.isNonNegativeInteger(channel , 'channel');
-    assert.lessThan(channel, itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
-
-    const data = sampler.data;
-
-    const l = data.length;
-
-    if (l === 0) {
-        //no data
-        return undefined;
-    }
-
-    let bestValue = data[channel];
-    let bestIndex = channel;
-
-    for (let i = channel + itemSize; i < l; i += itemSize) {
-        const value = data[i];
-
-        if (bestValue < value) {
-            bestValue = value;
-            bestIndex = i;
-        }
-
-    }
-
-    const width = this.width;
-
-    const itemIndex = (bestIndex / itemSize) | 0;
-
-    const x = itemIndex % width;
-    const y = (itemIndex / width) | 0;
-
-    return {
-        index: bestIndex,
-        value: bestValue,
-        x,
-        y
-    };
-}
-
-/**
- *
- * @param {Sampler2D} sampler
- * @param {number} [channel=0]
- * @returns {undefined|{x: number, index:number, y: number, value: number}}
- */
-function sampler2d_channel_compute_min(sampler, channel=0){
-    const itemSize = sampler.itemSize;
-
-    assert.isNumber(channel, "channel");
-    assert.isNonNegativeInteger(channel , 'channel');
-    assert.lessThan(channel, itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
-
-    const data = sampler.data;
-
-    const l = data.length;
-
-    if (l === 0) {
-        //no data
-        return undefined;
-    }
-
-    let bestValue = data[channel];
-    let bestIndex = channel;
-
-    for (let i = channel + itemSize; i < l; i += itemSize) {
-        const value = data[i];
-
-        if (bestValue > value) {
-            bestValue = value;
-            bestIndex = i;
-        }
-
-    }
-
-    const width = this.width;
-
-    const itemIndex = (bestIndex / itemSize) | 0;
-
-    const x = itemIndex % width;
-    const y = (itemIndex / width) | 0;
-
-    return {
-        index: bestIndex,
-        value: bestValue,
-        x,
-        y
-    };
-}
-
 /**
  *
  * @return {WorkerProxy}
@@ -65517,8 +65519,8 @@ function makeTerrainWorkerProxy() {
 
             useSampler(function (sampler) {
 
-                const min = sampler2d_channel_compute_min(sampler);
-                const max = sampler2d_channel_compute_max(sampler);
+                const min = Lib.sampler2d_channel_compute_min(sampler);
+                const max = Lib.sampler2d_channel_compute_max(sampler);
 
                 resolve({
                     min: min.value,
@@ -69433,7 +69435,7 @@ class ClippingPlaneContainmentComputingVisitor extends GeometrySpatialAccelerato
                 const plane_normal_z = plane.normal.z;
                 const plane_constant = plane.constant;
 
-                const side = computeAABB3PlaneSide(
+                const side = aabb3_compute_plane_side(
                     plane_normal_x,
                     plane_normal_y,
                     plane_normal_z,
@@ -72142,7 +72144,7 @@ class Asset {
 
         /**
          *
-         * @type {Array.<AssetDescription>}
+         * @type {Array<AssetDescription>}
          */
         this.dependencies = [];
 
@@ -78032,7 +78034,7 @@ class InstancedMeshGroup {
      * @param {number[]|ArrayLike<number>|Float32Array} transform 4x4 transform matrix of the instance
      */
     setTransformAt(index, transform) {
-        this.__attributeTransformArray.set(transform, index * 16);
+        array_copy(transform,0,this.__attributeTransformArray,index*16,16);
     }
 
     /**
@@ -78041,7 +78043,7 @@ class InstancedMeshGroup {
      * @param {number[]|ArrayLike<number>|Float32Array} color RGBA color in uint8 format (0...255), LDR
      */
     setColorAt(index, color) {
-        this.__attributeColorArray.set(color, index * 4);
+        array_copy(color,0,this.__attributeColorArray,index*4,4);
     }
 
     /**
@@ -79654,8 +79656,8 @@ class ExplicitBinaryBoundingVolumeHierarchy {
 
 /**
  *
- * @param {number[]} aabb
- * @param {number[]} frustum
+ * @param {number[]|Float32Array} aabb
+ * @param {number[]|Float32Array} frustum
  * @returns {number}
  */
 function aabb3_array_intersects_frustum_degree(aabb, frustum) {
@@ -79670,9 +79672,24 @@ function aabb3_array_intersects_frustum_degree(aabb, frustum) {
     return aabb3_intersects_frustum_degree(x0, y0, z0, x1, y1, z1, frustum);
 }
 
+/**
+ * Useful for traversals, such as tree-walking. When using - make sure you manage dependencies nad understand the call-graph to avoid overwriting data that is used else-where
+ * Using a pre-allocated continuous chunk of memory gets us better cache coherence
+ * @readonly
+ * @type {Uint32Array|{pointer:number}}
+ */
+const SCRATCH_UINT32_TRAVERSAL_STACK = new Uint32Array(781250);
+
+/**
+ * Pointer used to track current top of the stack, make sure to unwind once your traversal is done
+ * @type {number}
+ */
+SCRATCH_UINT32_TRAVERSAL_STACK.pointer = 0;
+
 //
 
-const traversal_stack$2 = [];
+const stack$7 = SCRATCH_UINT32_TRAVERSAL_STACK;
+
 /**
  *
  * @param {number[]} destination
@@ -79690,20 +79707,20 @@ function bvh_collect_user_data(destination, destination_offset, bvh, node) {
      *
      * @type {number}
      */
-    let traversal_cursor = 0;
+    const stack_top = stack$7.pointer++;
 
-    traversal_stack$2[traversal_cursor++] = node;
+    stack$7[stack_top] = node;
 
     let result_cursor = destination_offset;
 
-    while (traversal_cursor > 0) {
-        traversal_cursor--;
+    while (stack$7.pointer > stack_top) {
+        stack$7.pointer--;
 
         /**
          *
          * @type {number}
          */
-        const node = traversal_stack$2[traversal_cursor];
+        const node = stack$7[stack$7.pointer];
 
         const node_is_leaf = bvh.node_is_leaf(node);
 
@@ -79714,8 +79731,8 @@ function bvh_collect_user_data(destination, destination_offset, bvh, node) {
             const child2 = bvh.node_get_child2(node);
 
             // write to stack in reverse order, so that fist child ends up being visited first
-            traversal_stack$2[traversal_cursor++] = child1;
-            traversal_stack$2[traversal_cursor++] = child2;
+            stack$7[stack$7.pointer++] = child1;
+            stack$7[stack$7.pointer++] = child2;
 
         } else {
             // leaf node
@@ -79731,9 +79748,9 @@ function bvh_collect_user_data(destination, destination_offset, bvh, node) {
 
 //
 
-const traversal_stack$1 = [];
+const stack$6 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
-const scratch_aabb$1 = [];
+const scratch_aabb$1 = new Float32Array(6);
 
 /**
  *
@@ -79758,20 +79775,20 @@ function bvh_query_user_data_overlaps_frustum(
      *
      * @type {number}
      */
-    let traversal_cursor = 1;
+    const stack_top = stack$6.pointer++;
 
-    traversal_stack$1[0] = root;
+    stack$6[stack_top] = root;
 
     let result_cursor = result_offset;
 
-    while (traversal_cursor > 0) {
-        traversal_cursor--;
+    while (stack$6.pointer > stack_top) {
+        stack$6.pointer--;
 
         /**
          *
          * @type {number}
          */
-        const node = traversal_stack$1[traversal_cursor];
+        const node = stack$6[stack$6.pointer];
 
         // test node against the ray
         bvh.node_get_aabb(node, scratch_aabb$1);
@@ -79784,26 +79801,22 @@ function bvh_query_user_data_overlaps_frustum(
 
         const node_is_leaf = bvh.node_is_leaf(node);
 
-        if (!node_is_leaf) {
-
-            if (intersection === 2) {
-                // fully inside, fast collection path
-                result_cursor += bvh_collect_user_data(result, result_cursor, bvh, node);
-            } else {
-                // partially inside
-                // read in-order
-                const child1 = bvh.node_get_child1(node);
-                const child2 = bvh.node_get_child2(node);
-
-                // write to stack in reverse order, so that fist child ends up being visited first
-                traversal_stack$1[traversal_cursor++] = child1;
-                traversal_stack$1[traversal_cursor++] = child2;
-            }
+        if (node_is_leaf) {
+            // leaf node
+            result[result_cursor++] = bvh.node_get_user_data(node);
 
+        } else if (intersection === 2) {
+            // fully inside, fast collection path
+            result_cursor += bvh_collect_user_data(result, result_cursor, bvh, node);
         } else {
-            // leaf node
+            // partially inside
+            // read in-order
+            const child1 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
 
-            result[result_cursor++] = bvh.node_get_user_data(node);
+            // write to stack in reverse order, so that fist child ends up being visited first
+            stack$6[stack$6.pointer++] = child1;
+            stack$6[stack$6.pointer++] = child2;
         }
     }
 
@@ -79974,18 +79987,7 @@ class ShadedGeometryRendererContext {
     }
 }
 
-/**
- *
- * @type {number[]}
- */
-const traversal_stack = [];
-
-/**
- *
- * @type {number}
- */
-let traversal_cursor = 0;
-
+const stack$5 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
@@ -79999,7 +80001,6 @@ function bvh_query_leaves_generic(
     result, result_offset,
     bvh, query
 ) {
-    const stack_frame_address = traversal_cursor;
 
     const root = bvh.root;
 
@@ -80007,18 +80008,24 @@ function bvh_query_leaves_generic(
         return 0;
     }
 
-    traversal_stack[traversal_cursor++] = root;
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack$5.pointer++;
+
+    stack$5[stack_top] = root;
 
     let result_cursor = result_offset;
 
-    while (traversal_cursor > stack_frame_address) {
-        traversal_cursor--;
+    while (stack$5.pointer > stack_top) {
+        stack$5.pointer--;
 
         /**
          *
          * @type {number}
          */
-        const node = traversal_stack[traversal_cursor];
+        const node = stack$5[stack$5.pointer];
 
         // test node against the ray
         const pass = query.evaluate(node, bvh);
@@ -80036,8 +80043,8 @@ function bvh_query_leaves_generic(
             const child2 = bvh.node_get_child2(node);
 
             // write to stack in reverse order, so that fist child ends up being visited first
-            traversal_stack[traversal_cursor++] = child2;
-            traversal_stack[traversal_cursor++] = child1;
+            stack$5[stack$5.pointer++] = child2;
+            stack$5[stack$5.pointer++] = child1;
 
         } else {
             // leaf node
@@ -80046,9 +80053,6 @@ function bvh_query_leaves_generic(
         }
     }
 
-    // drop stack frame
-    traversal_cursor = stack_frame_address;
-
     return result_cursor - result_offset;
 }
 
@@ -82761,223 +82765,6 @@ function tryResolve(unresolvedTask) {
     return ResolutionType.READY;
 }
 
-/**
- * Created by Alex on 21/03/2016.
- */
-
-/**
- *
- * @param {Number} currentValue
- * @param {Number} upperLimit
- * @param {Number} [lowerLimit=0]
- * @constructor
- */
-const BoundedValue = function (currentValue, upperLimit, lowerLimit) {
-    /**
-     * @property {Number}
-     * @private
-     */
-    this.__value = currentValue !== undefined ? currentValue : 0;
-    /**
-     * @property {Number}
-     * @private
-     */
-    this.__limitUpper = upperLimit !== undefined ? upperLimit : 0;
-
-    /**
-     * @type {Number}
-     * @private
-     */
-    this.__limitLower = lowerLimit !== undefined ? lowerLimit : 0;
-
-    this.onChanged = new Signal();
-    this.onOverflow = new Signal();
-    this.onFilled = new Signal();
-
-    this.on = {
-        changed: this.onChanged,
-        overflow: this.onOverflow
-    };
-};
-
-/**
- *
- * @param {Number} v
- */
-BoundedValue.prototype.setUpperLimit = function (v) {
-    const oldValue = this.__limitUpper;
-    if (v === oldValue) {
-        //no change
-        return;
-    }
-    this.__limitUpper = v;
-    this.onChanged.send4(this.__value, this.__limitUpper, this.__value, oldValue);
-};
-
-
-/**
- *
- * @returns {Number}
- */
-BoundedValue.prototype.getUpperLimit = function () {
-    return this.__limitUpper;
-};
-
-/**
- *
- * @returns {Number}
- */
-BoundedValue.prototype.getLowerLimit = function () {
-    return this.__limitLower;
-};
-/**
- *
- * @param {Number} v
- */
-BoundedValue.prototype.setLowerLimit = function (v) {
-    const old = this.__limitLower;
-
-    if (v === old) {
-        //no change
-        return;
-    }
-
-    this.__limitLower = v;
-
-    //TODO change signal signature to include lower limit
-    this.onChanged.dispatch();
-};
-
-/**
- *
- * @param {Number} v
- */
-BoundedValue.prototype.setValue = function (v) {
-    const oldValue = this.__value;
-    if (oldValue === v) {
-        //no change
-        return;
-    }
-
-    const spill = v - this.__limitUpper;
-    this.__value = v;
-    //dispatch change
-    this.onChanged.send4(this.__value, this.__limitUpper, oldValue, this.__limitUpper);
-    if (spill > 0) {
-        this.onOverflow.send1(spill);
-    }
-    if (spill >= 0) {
-        this.onFilled.send0();
-    }
-};
-
-/**
- *
- * @returns {Number}
- */
-BoundedValue.prototype.getValue = function () {
-    return this.__value;
-};
-
-
-/**
- *
- * @returns {number}
- */
-BoundedValue.prototype.getFraction = function () {
-    return inverseLerp(this.__limitLower, this.__limitUpper, this.__value);
-};
-
-/**
- *
- */
-BoundedValue.prototype.setValueToLimit = function () {
-    this.setValue(this.__limitUpper);
-};
-
-/**
- *
- * @return {boolean}
- */
-BoundedValue.prototype.isValueAtLimit = function () {
-    return this.__value === this.__limitUpper;
-};
-
-/**
- *
- * @param {Number} val
- */
-BoundedValue.prototype.addValue = function (val) {
-    this.setValue(this.__value + val);
-};
-
-/**
- *
- * @param {BoundedValue} other
- * @returns {BoundedValue}
- */
-BoundedValue.prototype.copy = function (other) {
-    this.setUpperLimit(other.getUpperLimit());
-    this.setValue(other.getValue());
-    return this;
-};
-
-/**
- *
- * @param {BoundedValue} other
- * @returns {boolean}
- */
-BoundedValue.prototype.equals = function (other) {
-    return this.__value === other.__value && this.__limitLower === other.__limitLower && this.__limitUpper === other.__limitUpper;
-};
-
-/**
- *
- * @returns {number}
- */
-BoundedValue.prototype.hash = function () {
-    const v0 = computeHashFloat(this.__value);
-    const v1 = computeHashFloat(this.__limitLower);
-    const v2 = computeHashFloat(this.__limitUpper);
-
-    const h0 = (v0 << 5) - v0 + v1;
-
-    return (h0 << 5) - h0 + v2;
-};
-
-BoundedValue.prototype.toJSON = function () {
-    return {
-        value: this.__value,
-        limit: this.__limitUpper
-    };
-};
-
-BoundedValue.prototype.fromJSON = function (json) {
-    this.setUpperLimit(json.limit);
-    this.setValue(json.value);
-};
-
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-BoundedValue.prototype.toBinaryBuffer = function (buffer) {
-    buffer.writeFloat64(this.__value);
-    buffer.writeFloat64(this.__limitUpper);
-};
-
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-BoundedValue.prototype.fromBinaryBuffer = function (buffer) {
-    const value = buffer.readFloat64();
-    const upperLimit = buffer.readFloat64();
-
-    this.setUpperLimit(upperLimit);
-    this.setValue(value);
-};
-
 class ObservedMap {
     /**
      * @template K,V
@@ -83980,10 +83767,6 @@ class BinaryHeap {
     }
 }
 
-/**
- * Created by Alex on 03/09/2014.
- */
-
 /**
  * @enum {number}
  */
@@ -83993,9 +83776,225 @@ const AssetLoadState = {
     Loading: 2,
     Succeeded: 3,
     Failed: 4
+};
+
+/**
+ * Created by Alex on 21/03/2016.
+ */
+
+/**
+ *
+ * @param {Number} currentValue
+ * @param {Number} upperLimit
+ * @param {Number} [lowerLimit=0]
+ * @constructor
+ */
+const BoundedValue = function (currentValue, upperLimit, lowerLimit) {
+    /**
+     * @property {Number}
+     * @private
+     */
+    this.__value = currentValue !== undefined ? currentValue : 0;
+    /**
+     * @property {Number}
+     * @private
+     */
+    this.__limitUpper = upperLimit !== undefined ? upperLimit : 0;
+
+    /**
+     * @type {Number}
+     * @private
+     */
+    this.__limitLower = lowerLimit !== undefined ? lowerLimit : 0;
+
+    this.onChanged = new Signal();
+    this.onOverflow = new Signal();
+    this.onFilled = new Signal();
+
+    this.on = {
+        changed: this.onChanged,
+        overflow: this.onOverflow
+    };
+};
+
+/**
+ *
+ * @param {Number} v
+ */
+BoundedValue.prototype.setUpperLimit = function (v) {
+    const oldValue = this.__limitUpper;
+    if (v === oldValue) {
+        //no change
+        return;
+    }
+    this.__limitUpper = v;
+    this.onChanged.send4(this.__value, this.__limitUpper, this.__value, oldValue);
+};
+
+
+/**
+ *
+ * @returns {Number}
+ */
+BoundedValue.prototype.getUpperLimit = function () {
+    return this.__limitUpper;
+};
+
+/**
+ *
+ * @returns {Number}
+ */
+BoundedValue.prototype.getLowerLimit = function () {
+    return this.__limitLower;
+};
+/**
+ *
+ * @param {Number} v
+ */
+BoundedValue.prototype.setLowerLimit = function (v) {
+    const old = this.__limitLower;
+
+    if (v === old) {
+        //no change
+        return;
+    }
+
+    this.__limitLower = v;
+
+    //TODO change signal signature to include lower limit
+    this.onChanged.dispatch();
 };
 
+/**
+ *
+ * @param {Number} v
+ */
+BoundedValue.prototype.setValue = function (v) {
+    const oldValue = this.__value;
+    if (oldValue === v) {
+        //no change
+        return;
+    }
 
+    const spill = v - this.__limitUpper;
+    this.__value = v;
+    //dispatch change
+    this.onChanged.send4(this.__value, this.__limitUpper, oldValue, this.__limitUpper);
+    if (spill > 0) {
+        this.onOverflow.send1(spill);
+    }
+    if (spill >= 0) {
+        this.onFilled.send0();
+    }
+};
+
+/**
+ *
+ * @returns {Number}
+ */
+BoundedValue.prototype.getValue = function () {
+    return this.__value;
+};
+
+
+/**
+ *
+ * @returns {number}
+ */
+BoundedValue.prototype.getFraction = function () {
+    return inverseLerp(this.__limitLower, this.__limitUpper, this.__value);
+};
+
+/**
+ *
+ */
+BoundedValue.prototype.setValueToLimit = function () {
+    this.setValue(this.__limitUpper);
+};
+
+/**
+ *
+ * @return {boolean}
+ */
+BoundedValue.prototype.isValueAtLimit = function () {
+    return this.__value === this.__limitUpper;
+};
+
+/**
+ *
+ * @param {Number} val
+ */
+BoundedValue.prototype.addValue = function (val) {
+    this.setValue(this.__value + val);
+};
+
+/**
+ *
+ * @param {BoundedValue} other
+ * @returns {BoundedValue}
+ */
+BoundedValue.prototype.copy = function (other) {
+    this.setUpperLimit(other.getUpperLimit());
+    this.setValue(other.getValue());
+    return this;
+};
+
+/**
+ *
+ * @param {BoundedValue} other
+ * @returns {boolean}
+ */
+BoundedValue.prototype.equals = function (other) {
+    return this.__value === other.__value && this.__limitLower === other.__limitLower && this.__limitUpper === other.__limitUpper;
+};
+
+/**
+ *
+ * @returns {number}
+ */
+BoundedValue.prototype.hash = function () {
+    const v0 = computeHashFloat(this.__value);
+    const v1 = computeHashFloat(this.__limitLower);
+    const v2 = computeHashFloat(this.__limitUpper);
+
+    const h0 = (v0 << 5) - v0 + v1;
+
+    return (h0 << 5) - h0 + v2;
+};
+
+BoundedValue.prototype.toJSON = function () {
+    return {
+        value: this.__value,
+        limit: this.__limitUpper
+    };
+};
+
+BoundedValue.prototype.fromJSON = function (json) {
+    this.setUpperLimit(json.limit);
+    this.setValue(json.value);
+};
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ */
+BoundedValue.prototype.toBinaryBuffer = function (buffer) {
+    buffer.writeFloat64(this.__value);
+    buffer.writeFloat64(this.__limitUpper);
+};
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ */
+BoundedValue.prototype.fromBinaryBuffer = function (buffer) {
+    const value = buffer.readFloat64();
+    const upperLimit = buffer.readFloat64();
+
+    this.setUpperLimit(upperLimit);
+    this.setValue(value);
+};
+
 class PendingAsset {
     /**
      *
@@ -84053,7 +84052,12 @@ class PendingAsset {
 
         return max_priority;
     }
-}
+}
+
+/**
+ * Created by Alex on 03/09/2014.
+ */
+
 
 let Response$1 = class Response {
     /**
@@ -84084,141 +84088,144 @@ function get_pending_asset_priority_score(pending_asset) {
 class AssetManager {
     /**
      *
-     * @param {Engine} engine
-     * @constructor
+     * @type {HashMap<AssetDescription, Asset>}
+     * @private
      */
-    constructor(engine) {
-        /**
-         *
-         * @type {HashMap<AssetDescription, Asset>}
-         * @private
-         */
-        this.assets = new HashMap({
-            capacity: 1024
-        });
+    assets = new HashMap({
+        capacity: 1024
+    });
 
-        /**
-         *
-         * @type {ObservedMap<AssetDescription, PendingAsset>}
-         * @private
-         */
-        this.request_map = new ObservedMap(new HashMap());
+    /**
+     *
+     * @type {ObservedMap<AssetDescription, PendingAsset>}
+     */
+    request_map = new ObservedMap(new HashMap());
 
-        /**
-         * Waiting queue for assets that haven't yet been scheduled (passed to relevant loader)
-         * @type {BinaryHeap<PendingAsset>}
-         * @private
-         */
-        this.__pending_asset_wait_queue = new BinaryHeap(get_pending_asset_priority_score);
-        /**
-         * Assets currently being processed by loaders
-         * @type {Set<PendingAsset>}
-         * @private
-         */
-        this.__pending_asset_active_load_set = new Set();
+    /**
+     * Waiting queue for assets that haven't yet been scheduled (passed to relevant loader)
+     * @type {BinaryHeap<PendingAsset>}
+     * @private
+     */
+    #pending_asset_wait_queue = new BinaryHeap(get_pending_asset_priority_score);
+    /**
+     * Assets currently being processed by #loaders
+     * @type {Set<PendingAsset>}
+     * @private
+     */
+    #pending_asset_active_load_set = new Set();
 
-        /**
-         * Maximum number of requests that can be handled at the same time
-         * Since most of the requests are handled over the network, this can help you control network concurrency,
-         * this can be useful to keep some network slots available for high-priority requests such as UI related ones
-         * TODO currently nested asset requests are not recognized, so if nesting level exceeds concurrency - it will lead to a deadlock
-         * @type {number}
-         */
-        this.load_concurrency = Infinity;
+    /**
+     * Maximum number of requests that can be handled at the same time
+     * Since most of the requests are handled over the network, this can help you control network concurrency,
+     * this can be useful to keep some network slots available for high-priority requests such as UI related ones
+     * TODO currently nested asset requests are not recognized, so if nesting level exceeds concurrency - it will lead to a deadlock
+     * @type {number}
+     */
+    load_concurrency = Infinity;
 
-        /**
-         * Registered loaders
-         * @private
-         * @type {Object<AssetLoader>}
-         */
-        this.loaders = {};
+    /**
+     * Registered #loaders
+     * @private
+     * @type {Object<AssetLoader>}
+     */
+    #loaders = {};
 
-        /**
-         * After asset is loaded, a chain of transforms can be applied to it, these are registered here
-         * Transformers are executed in the order in which they are added
-         * Identified by asset "type" string
-         * @type {Object<AssetTransformer[]>}
-         * @private
-         */
-        this.transformers = {};
+    /**
+     * After asset is loaded, a chain of transforms can be applied to it, these are registered here
+     * Transformers are executed in the order in which they are added
+     * Identified by asset "type" string
+     * @type {Object<AssetTransformer[]>}
+     * @private
+     */
+    #transformers = {};
 
-        /**
-         * Named links to specific assets. Useful to later re-mapping assets and having meaningful names for them
-         * @type {Map<string, AssetDescription>}
-         * @private
-         */
-        this.aliases = new Map();
+    /**
+     * Named links to specific assets. Useful to later re-mapping assets and having meaningful names for them
+     * @type {Map<string, AssetDescription>}
+     * @private
+     */
+    #aliases = new Map();
 
-        /**
-         * This will be added to asset path for actual network resolution
-         * @type {string}
-         * @private
-         */
-        this.rootPath = '';
+    /**
+     * This will be added to asset path for actual network resolution
+     * @type {string}
+     * @private
+     */
+    rootPath = '';
 
-        /**
-         *
-         * @type {Engine}
-         * @private
-         */
-        this.__engine = engine;
+    /**
+     *
+     * @type {CrossOriginConfig}
+     */
+    crossOriginConfig = new CrossOriginConfig();
 
-        /**
-         *
-         * @type {CrossOriginConfig}
-         */
-        this.crossOriginConfig = new CrossOriginConfig();
+    /**
+     *
+     * @type {HashSet<AssetDescription>}
+     * @private
+     */
+    #failures = new HashSet();
 
-        /**
-         *
-         * @type {HashSet<AssetDescription>}
-         * @private
-         */
-        this.failures = new HashSet();
+    /**
+     * Queue of responses that are waiting to be dispatched
+     * @type {Deque<Response>}
+     * @private
+     */
+    #response_queue = new Deque();
 
-        /**
-         * Queue of responses that are waiting to be dispatched
-         * @type {Deque<Response>}
-         * @private
-         */
-        this.__response_queue = new Deque();
+    /**
+     *
+     * @type {Task}
+     * @private
+     */
+    #response_processor = new Task({
+        name: "Asset Manager Response processor",
+        cycleFunction: () => {
+            if (this.#response_queue.isEmpty()) {
+                return TaskSignal.Yield;
+            }
 
-        /**
-         *
-         * @type {Task}
-         * @private
-         */
-        this.__response_processor = new Task({
-            name: "Asset Manager Response processor",
-            cycleFunction: () => {
-                if (this.__response_queue.isEmpty()) {
-                    return TaskSignal.Yield;
-                }
+            const response = this.#response_queue.removeFirst();
 
-                const response = this.__response_queue.removeFirst();
+            this.#process_response(response);
 
-                this.__process_response(response);
+            return TaskSignal.Continue;
+        }
+    });
 
-                return TaskSignal.Continue;
-            }
-        });
+    /**
+     *
+     * @type {boolean}
+     * @private
+     */
+    #is_running = false;
+
+    /**
+     *
+     * @type {Engine|null}
+     * @private
+     */
+    #engine = null;
+
+    /**
+     *
+     * @param {Engine} engine
+     * @constructor
+     */
+    constructor(engine) {
+
+        this.#engine = engine;
 
-        /**
-         *
-         * @type {boolean}
-         * @private
-         */
-        this.__is_running = false;
     }
 
     startup() {
-        if (this.__is_running) {
+        if (this.#is_running) {
             return;
         }
 
-        this.__engine.executor.run(this.__response_processor);
+        this.#engine.executor.run(this.#response_processor);
 
-        this.__is_running = true;
+        this.#is_running = true;
     }
 
     /**
@@ -84227,18 +84234,18 @@ class AssetManager {
      * @return {Promise<void>}
      */
     async shutdown(immediate = false) {
-        if (!this.__is_running) {
+        if (!this.#is_running) {
             return;
         }
 
         if (!immediate) {
             // wait until all responses have been processed
-            await Promise.allSettled([Task.promise(this.__response_processor)]);
+            await Promise.allSettled([Task.promise(this.#response_processor)]);
         }
 
-        this.__engine.executor.removeTask(this.__response_processor);
+        this.#engine.executor.removeTask(this.#response_processor);
 
-        this.__is_running = false;
+        this.#is_running = false;
     }
 
     /**
@@ -84327,6 +84334,8 @@ class AssetManager {
             console.warn(`Another asset under ${assetDescription} already exists and will be replaced`);
         }
 
+        // TODO check for assets in-flight
+
         this.assets.set(assetDescription, asset);
     }
 
@@ -84335,7 +84344,7 @@ class AssetManager {
      * @param {Response} response
      * @private
      */
-    __process_response(response) {
+    #process_response(response) {
 
         try {
             response.request.successCallback(response.asset);
@@ -84350,8 +84359,8 @@ class AssetManager {
      * @param {AssetRequest} request
      * @private
      */
-    __schedule_response(asset, request) {
-        this.__response_queue.add(new Response$1(asset, request));
+    #schedule_response(asset, request) {
+        this.#response_queue.add(new Response$1(asset, request));
     }
 
     /**
@@ -84359,11 +84368,11 @@ class AssetManager {
      * @param {PendingAsset} asset
      * @private
      */
-    __schedule_load(asset) {
-        if (this.__pending_asset_active_load_set.size < this.load_concurrency) {
-            this.__dispatch_pending_asset(asset);
+    #schedule_load(asset) {
+        if (this.#pending_asset_active_load_set.size < this.load_concurrency) {
+            this.#dispatch_pending_asset(asset);
         } else {
-            this.__pending_asset_wait_queue.push(asset);
+            this.#pending_asset_wait_queue.push(asset);
         }
     }
 
@@ -84372,17 +84381,17 @@ class AssetManager {
      * @param {PendingAsset} asset
      * @private
      */
-    __force_load(asset) {
+    #force_load(asset) {
         // check if the asset is already being loaded
-        if (this.__pending_asset_active_load_set.has(asset)) {
+        if (this.#pending_asset_active_load_set.has(asset)) {
             return;
         }
 
         // remove from queue
-        this.__pending_asset_wait_queue.delete(asset);
+        this.#pending_asset_wait_queue.delete(asset);
 
         // dispatch
-        this.__dispatch_pending_asset(asset);
+        this.#dispatch_pending_asset(asset);
 
     }
 
@@ -84391,21 +84400,21 @@ class AssetManager {
      * @param {PendingAsset} pending_asset
      * @private
      */
-    __handle_asset_resolved(pending_asset) {
+    #handle_asset_resolved(pending_asset) {
         // console.log(`Asset resolved ${pending_asset.description}`); // DEBUG
 
-        const active_set = this.__pending_asset_active_load_set;
+        const active_set = this.#pending_asset_active_load_set;
 
         this.request_map.delete(pending_asset.description);
         active_set.delete(pending_asset);
 
-        const queue = this.__pending_asset_wait_queue;
+        const queue = this.#pending_asset_wait_queue;
 
         // schedule more if possible
         while (!queue.isEmpty() && active_set.size < this.load_concurrency) {
             const load = queue.pop();
 
-            this.__dispatch_pending_asset(load);
+            this.#dispatch_pending_asset(load);
         }
     }
 
@@ -84414,7 +84423,7 @@ class AssetManager {
      * @param {PendingAsset} pendingAsset
      * @private
      */
-    __dispatch_pending_asset(pendingAsset) {
+    #dispatch_pending_asset(pendingAsset) {
         // console.log(`Asset load dispatched ${pendingAsset.description}`); // DEBUG
 
         const requests = pendingAsset.requests;
@@ -84422,7 +84431,7 @@ class AssetManager {
         const type = assetDescription.type;
         const path = assetDescription.path;
 
-        const loader = this.loaders[type];
+        const loader = this.#loaders[type];
 
         if (loader === undefined) {
             let reported_error = false;
@@ -84431,7 +84440,7 @@ class AssetManager {
                 const assetRequest = requests[i];
 
                 if (typeof assetRequest.failureCallback === "function") {
-                    assetRequest.failureCallback(`no loader exists for asset type '${type}', valid types are: ${Object.keys(this.loaders).join(', ')}`);
+                    assetRequest.failureCallback(`no loader exists for asset type '${type}', valid types are: ${Object.keys(this.#loaders).join(', ')}`);
                 } else {
                     //uncaught
                     if (!reported_error) {
@@ -84441,16 +84450,16 @@ class AssetManager {
                 }
             }
 
-            this.__handle_asset_resolved(pendingAsset);
+            this.#handle_asset_resolved(pendingAsset);
 
             return;
         }
 
         // mark as being loaded
-        this.__pending_asset_active_load_set.add(pendingAsset);
+        this.#pending_asset_active_load_set.add(pendingAsset);
 
         const assets = this.assets;
-        const failures = this.failures;
+        const failures = this.#failures;
 
 
         /**
@@ -84474,7 +84483,7 @@ class AssetManager {
             let asset = loaded_asset;
 
             // apply transform chain
-            const transformers = this.transformers[type];
+            const transformers = this.#transformers[type];
             if (transformers !== undefined) {
                 const transformer_count = transformers.length;
                 for (let i = 0; i < transformer_count; i++) {
@@ -84497,13 +84506,13 @@ class AssetManager {
             assets.set(assetDescription, asset);
 
             //clear callbacks etc.
-            this.__handle_asset_resolved(pendingAsset);
+            this.#handle_asset_resolved(pendingAsset);
 
 
             // process callbacks
             for (let i = 0; i < requests.length; i++) {
                 const request = requests[i];
-                this.__schedule_response(asset, request);
+                this.#schedule_response(asset, request);
             }
 
         };
@@ -84531,7 +84540,7 @@ class AssetManager {
             }
 
             //clear callbacks etc.
-            this.__handle_asset_resolved(pendingAsset);
+            this.#handle_asset_resolved(pendingAsset);
 
             // record failure
             failures.add(assetDescription);
@@ -84597,15 +84606,15 @@ class AssetManager {
 
         if (shouldSchedule) {
             // not loading yet, lets create a load container and schedule it
-            this.__schedule_load(pendingAsset);
+            this.#schedule_load(pendingAsset);
         } else {
             // update priority queue if necessary
-            this.__pending_asset_wait_queue.updateElementScore(pendingAsset);
+            this.#pending_asset_wait_queue.updateElementScore(pendingAsset);
         }
 
 
         if (request.getFlag(AssetRequestFlags.SkipQueue)) {
-            this.__force_load(pendingAsset);
+            this.#force_load(pendingAsset);
         }
     }
 
@@ -84627,7 +84636,7 @@ class AssetManager {
     getLoaderByType(type) {
         assert.isString(type, 'type');
 
-        return this.loaders[type];
+        return this.#loaders[type];
     }
 
     /**
@@ -84636,7 +84645,7 @@ class AssetManager {
      * @return {AssetDescription[]}
      * @private
      */
-    __getLoadedAssetDescriptorsByType(type) {
+    #getLoadedAssetDescriptorsByType(type) {
         const loaded_assets = Array.from(this.assets.keys());
         return loaded_assets.filter(t => t.type === type);
     }
@@ -84647,18 +84656,18 @@ class AssetManager {
      * @param {AssetTransformer<T>} transformer
      */
     registerTransformer(type, transformer) {
-        let transformers = this.transformers[type];
+        let transformers = this.#transformers[type];
 
         if (transformers === undefined) {
             transformers = [];
 
-            this.transformers[type] = transformers;
+            this.#transformers[type] = transformers;
         }
 
         transformers.push(transformer);
 
         // check for loaded assets
-        const matching_assets = this.__getLoadedAssetDescriptorsByType(type);
+        const matching_assets = this.#getLoadedAssetDescriptorsByType(type);
 
         if (matching_assets.length > 0) {
             console.warn(`Following assets of matching type '${type}' are already loaded and transform is not applied to them:\n\t${matching_assets.join('\n\t')}`);
@@ -84673,7 +84682,7 @@ class AssetManager {
      */
     unregisterTransformer(type, transformer) {
 
-        const transformers = this.transformers[type];
+        const transformers = this.#transformers[type];
 
         if (transformers === undefined) {
             // not found
@@ -84686,7 +84695,7 @@ class AssetManager {
         }
 
         // check for loaded assets
-        const matching_assets = this.__getLoadedAssetDescriptorsByType(type);
+        const matching_assets = this.#getLoadedAssetDescriptorsByType(type);
 
         if (matching_assets.length > 0) {
             console.warn(`Following assets of matching type '${type}' are already loaded and transform was probably already applied to them:\n\t${matching_assets.join('\n\t')}`);
@@ -84725,11 +84734,11 @@ class AssetManager {
 
         } else {
 
-            await loader.link(this, this.__engine);
+            await loader.link(this, this.#engine);
 
         }
 
-        this.loaders[type] = loader;
+        this.#loaders[type] = loader;
 
         return loader;
     }
@@ -84748,7 +84757,7 @@ class AssetManager {
         }
 
         // first remove the loader from registry so no further asset requests can be made
-        delete this.loaders[type];
+        delete this.#loaders[type];
 
         // TODO address all pending requests, possibly waiting for all of them to finalize
 
@@ -84784,7 +84793,7 @@ class AssetManager {
     isFailed(path, type) {
         const ad = new AssetDescription(path, type);
 
-        return this.failures.has(ad);
+        return this.#failures.has(ad);
     }
 
     /**
@@ -84796,7 +84805,7 @@ class AssetManager {
         assert.typeOf(alias, 'string', 'alias');
 
         // resolve alias
-        const assetDescription = this.aliases.get(alias);
+        const assetDescription = this.#aliases.get(alias);
 
         if (assetDescription === undefined) {
             return new Promise.reject(`Alias '${alias}' not found`);
@@ -84814,7 +84823,7 @@ class AssetManager {
 
         // todo consider cloning result to protect against mutation
 
-        return this.aliases.get(alias);
+        return this.#aliases.get(alias);
 
     }
 
@@ -84831,7 +84840,7 @@ class AssetManager {
 
         const assetDescription = new AssetDescription(path, type);
 
-        this.aliases.set(alias, assetDescription);
+        this.#aliases.set(alias, assetDescription);
     }
 }
 
@@ -86414,18 +86423,31 @@ class IncrementalDeltaSet {
     finalizeUpdate() {
         assert.equal(this.state, IncrementalDeltaSetState.Building, `Expected BUILDING state, instead got '${this.state}'`);
 
-        this.size = this.__elements_cursor;
+        const array_main_count = this.__elements_cursor;
+        const array_previous_count = this.__swap_elements_count;
+
+        this.size = array_main_count;
 
         // sort newly populated elements array
-        array_shrink_to_size(this.__elements, this.size);
-        this.__elements.sort(this.__compare);
+        const array_main = this.__elements;
+        const array_previous = this.__swap_elements;
+
+        const compare = this.__compare;
+
+        const onAdded = this.onAdded;
+        const onRemoved = this.onRemoved;
+
+        array_shrink_to_size(array_main, array_main_count);
+        array_main.sort(compare);
+
 
         let i0 = 0, i1 = 0;
-        while (i0 < this.size && i1 < this.__swap_elements_count) {
-            const el_0 = this.__elements[i0];
-            const el_1 = this.__swap_elements[i1];
 
-            const diff = this.__compare(el_0, el_1);
+        while (i0 < array_main_count && i1 < array_previous_count) {
+            const el_0 = array_main[i0];
+            const el_1 = array_previous[i1];
+
+            const diff = compare(el_0, el_1);
 
             if (diff === 0) {
                 i0++;
@@ -86434,20 +86456,20 @@ class IncrementalDeltaSet {
             } else if (diff < 0) {
                 i0++;
                 // addition
-                this.onAdded.send1(el_0);
+                onAdded.send1(el_0);
             } else {
                 i1++;
                 // removal
-                this.onRemoved.send1(el_1);
+                onRemoved.send1(el_1);
             }
         }
 
         // process remainders
-        for (; i0 < this.size; i0++) {
-            this.onAdded.send1(this.__elements[i0]);
+        for (; i0 < array_main_count; i0++) {
+            onAdded.send1(array_main[i0]);
         }
-        for (; i1 < this.__swap_elements_count; i1++) {
-            this.onRemoved.send1(this.__swap_elements[i1]);
+        for (; i1 < array_previous_count; i1++) {
+            onRemoved.send1(array_previous[i1]);
         }
 
         this.state = IncrementalDeltaSetState.Ready;
@@ -95839,7 +95861,11 @@ GraphicsEngine.prototype.start = function () {
         antialias: true,
         logarithmicDepthBuffer: false,
         canvas,
-        context
+        context,
+        /**
+         * @see https://registry.khronos.org/webgl/specs/latest/1.0/#5.2
+         */
+        powerPreference:"high-performance"
     };
 
     const webGLRenderer = this.renderer = new WebGLRenderer(rendererParameters);
@@ -96609,117 +96635,166 @@ function readPositionFromMouseEvent(result, event, source = event.target) {
     result.set(x, y);
 }
 
-/**
- *
- * @param {EventTarget} domElement html element
- * @constructor
- */
-function PointerDevice(domElement) {
-    assert.notEqual(domElement, undefined, "domElement is undefined");
+class PointerDevice {
 
     /**
-     * @private
-     * @type {boolean}
+     * @readonly
+     * @type {Vector2}
      */
-    this.isRunning = false;
+    position = new Vector2();
 
     /**
-     *
-     * @type {Element}
-     * @private
+     * @readonly
+     * @type {Vector2}
      */
-    this.__target = null;
+    #anchor_touch_last = new Vector2();
+
+    #globalUp = new Signal();
+
+    #touchStart = new Signal();
+    #touchEnd = new Signal();
+    #touchMove = new Signal();
+
+    /**
+     * @readonly
+     */
+    on = {
+        down: new Signal(),
+        up: new Signal(),
+        move: new Signal(),
+        tap: new Signal(),
+        drag: new Signal(),
+        dragStart: new Signal(),
+        dragEnd: new Signal(),
+        wheel: new Signal(),
+        pinch: new Signal(),
+        pinchStart: new Signal(),
+        pinchEnd: new Signal(),
+    };
 
     /**
      *
-     * @type {EventTarget}
+     * @type {Element|null}
+     * @private
      */
-    this.domElement = domElement;
+    #target = null;
 
-    const position = this.position = new Vector2();
+    /**
+     * @private
+     * @type {boolean}
+     */
+    isRunning = false;
 
     /**
      *
-     * @param {MouseEvent} event
+     * @param {EventTarget} domElement html element
+     * @constructor
      */
-    this.eventHandlerMouseMove = (event) => {
-        event.preventDefault();
+    constructor(domElement) {
+        assert.defined(domElement, "domElement");
 
-        this.__target = event.target;
 
-        this.readPointerPositionFromEvent(position, event);
+        /**
+         *
+         * @type {EventTarget}
+         */
+        this.domElement = domElement;
 
-        this.on.move.send3(position, event, new Vector2(event.movementX, event.movementY));
-    };
-    this.eventHandlerMouseUp = (event) => {
-        this.readPointerPositionFromEvent(position, event);
-        this.on.up.send2(position, event);
-    };
-    this.eventHandlerMouseDown = (event) => {
-        this.readPointerPositionFromEvent(position, event);
-        this.on.down.send2(position, event);
-    };
 
-    const touchStart = new Signal();
-    const touchEnd = new Signal();
-    const touchMove = new Signal();
+        this.#touchStart.add((param0, param1, param2) => {
+            this.on.down.send3(param0, param1, param2);
+        });
 
-    touchStart.add((param0, param1, param2) => {
-        this.on.down.send3(param0, param1, param2);
-    });
+        this.#touchEnd.add((param0, param1, param2) => {
+            this.on.up.send3(param0, param1, param2);
+        });
+        this.#touchMove.add((param0, param1, param2) => {
+            this.on.move.send3(param0, param1, param2);
+        });
 
-    touchEnd.add((param0, param1, param2) => {
-        this.on.up.send3(param0, param1, param2);
-    });
-    touchMove.add((param0, param1, param2) => {
-        this.on.move.send3(param0, param1, param2);
-    });
 
-    const anchor_touch_last = new Vector2();
+        //constructed events
+        observeTap(this.on.up, this.on.down, this.on.move, 10, this.on.tap);
+        observeDrag(this.#globalUp, this.on.down, this.on.move, this.on.dragStart, this.on.dragEnd, this.on.drag);
+        observePinch({
+            touchStart: this.#touchStart,
+            touchEnd: this.#touchEnd,
+            touchMove: this.#touchMove,
+            pinch: this.on.pinch,
+            pinchStart: this.on.pinchStart,
+            pinchEnd: this.on.pinchEnd,
+            device: this
+        });
+    }
 
-    this.eventHandlerTouchStart = function (event) {
-        getTouchCenter(event.touches, position);
-        touchStart.send2(position, event);
+    /**
+     *
+     * @param {MouseEvent} event
+     */
+    #eventHandlerMouseDown = (event) => {
+        this.readPointerPositionFromEvent(this.position, event);
+        this.on.down.send2(this.position, event);
+    }
 
-        anchor_touch_last.copy(position);
-    };
+    /**
+     *
+     * @param {TouchEvent} event
+     */
+    #eventHandlerGlobalTouchEnd = (event) => {
+        getTouchCenter(event.touches, this.position);
+        this.#globalUp.send2(this.position, event);
+    }
 
-    this.eventHandlerTouchEnd = function (event) {
-        getTouchCenter(event.touches, position);
-        touchEnd.send2(position, event);
-    };
+    /**
+     *
+     * @param {MouseEvent} event
+     */
+    #eventHandlerMouseUp = (event) => {
+        this.readPointerPositionFromEvent(this.position, event);
+        this.on.up.send2(this.position, event);
+    }
+
+    /**
+     *
+     * @param {MouseEvent} event
+     */
+    #eventHandlerGlobalMouseUp = (event) => {
+        this.readPointerPositionFromEvent(this.position, event);
+        this.#globalUp.send2(this.position, event);
+    }
+
+    /**
+     *
+     * @param {TouchEvent} event
+     */
+    #eventHandlerTouchEnd = (event) => {
+        getTouchCenter(event.touches, this.position);
+        this.#touchEnd.send2(this.position, event);
+    }
 
-    this.eventHandlerTouchMove = function (event) {
+    /**
+     *
+     * @param {TouchEvent} event
+     */
+    #eventHandlerTouchMove = (event) => {
         event.preventDefault();
 
         getTouchCenter(event.touches, position);
 
         const delta = new Vector2();
 
-        delta.subVectors(position, anchor_touch_last);
-
-        touchMove.send3(position, event, delta);
+        delta.subVectors(this.position, this.#anchor_touch_last);
 
-        anchor_touch_last.copy(position);
-    };
-
-    const globalUp = new Signal();
-
-    this.eventHandlerGlobalTouchEnd = (event) => {
-        getTouchCenter(event.touches, position);
-        globalUp.send2(position, event);
-    };
+        this.#touchMove.send3(this.position, event, delta);
 
-    this.eventHandlerGlobalMouseUp = (event) => {
-        this.readPointerPositionFromEvent(position, event);
-        globalUp.send2(position, event);
-    };
+        this.#anchor_touch_last.copy(this.position);
+    }
 
     /**
      *
      * @param {WheelEvent} event
      */
-    this.eventHandlerWheel = (event) => {
+    #eventHandlerWheel = (event) => {
         event.preventDefault();
 
         //deltas have inconsistent values across browsers, so we will normalize them
@@ -96730,148 +96805,146 @@ function PointerDevice(domElement) {
 
         const delta = new Vector3$1(x, y, z);
 
-        this.readPointerPositionFromEvent(position, event);
+        this.readPointerPositionFromEvent(this.position, event);
 
-        this.on.wheel.send3(delta, position, event);
-    };
+        this.on.wheel.send3(delta, this.position, event);
+    }
 
+    /**
+     *
+     * @param {TouchEvent} event
+     */
+    #eventHandlerTouchStart = (event) => {
+        getTouchCenter(event.touches, this.position);
+        this.#touchStart.send2(this.position, event);
 
-    this.on = {
-        down: new Signal(),
-        up: new Signal(),
-        move: new Signal(),
-        tap: new Signal(),
-        drag: new Signal(),
-        dragStart: new Signal(),
-        dragEnd: new Signal(),
-        wheel: new Signal(),
-        pinch: new Signal(),
-        pinchStart: new Signal(),
-        pinchEnd: new Signal(),
-    };
+        this.#anchor_touch_last.copy(this.position);
+    }
 
-    //constructed events
-    observeTap(this.on.up, this.on.down, this.on.move, 10, this.on.tap);
-    observeDrag(globalUp, this.on.down, this.on.move, this.on.dragStart, this.on.dragEnd, this.on.drag);
-    observePinch({
-        touchStart: touchStart,
-        touchEnd: touchEnd,
-        touchMove: touchMove,
-        pinch: this.on.pinch,
-        pinchStart: this.on.pinchStart,
-        pinchEnd: this.on.pinchEnd
-    });
-}
+    /**
+     *
+     * @param {MouseEvent} event
+     */
+    #eventHandlerMouseMove = (event) => {
+        event.preventDefault();
 
-/**
- *
- * @return {Element}
- */
-PointerDevice.prototype.getTargetElement = function () {
-    return this.__target;
-};
+        this.#target = event.target;
 
-/**
- *
- * @param {Element} el
- */
-PointerDevice.prototype.setTargetElement = function (el) {
-    assert.defined(el, 'el');
-    assert.notNull(el, 'el');
+        this.readPointerPositionFromEvent(this.position, event);
 
-    if (this.__target === el) {
-        // no change
-        return;
+        this.on.move.send3(this.position, event, new Vector2(event.movementX, event.movementY));
     }
 
-    let was_running = this.isRunning;
-
-    if (was_running) {
-        // disconnect from previous target
-        this.stop();
+    /**
+     *
+     * @return {Element}
+     */
+    getTargetElement() {
+        return this.#target;
     }
 
-    this.__target = el;
+    /**
+     *
+     * @param {Element} el
+     */
+    setTargetElement(el) {
+        assert.defined(el, 'el');
+        assert.notNull(el, 'el');
 
-    if (was_running) {
-        // restart to maintain original state
-        this.start();
-    }
-};
+        if (this.#target === el) {
+            // no change
+            return;
+        }
 
-/**
- *
- * @param {Vector2} result
- * @param {MouseEvent|TouchEvent} event
- */
-PointerDevice.prototype.readPointerPositionFromEvent = function (result, event) {
-    readPositionFromMouseEvent(result, event, this.domElement);
-};
+        let was_running = this.isRunning;
 
-PointerDevice.prototype.start = function () {
-    if (this.isRunning) {
-        //already running
-        return;
+        if (was_running) {
+            // disconnect from previous target
+            this.stop();
+        }
+
+        this.#target = el;
+
+        if (was_running) {
+            // restart to maintain original state
+            this.start();
+        }
+    }
+
+    /**
+     *
+     * @param {Vector2} result
+     * @param {MouseEvent|TouchEvent} event
+     */
+    readPointerPositionFromEvent(result, event) {
+        readPositionFromMouseEvent(result, event, this.domElement);
     }
 
-    this.isRunning = true;
+    start() {
+        if (this.isRunning) {
+            //already running
+            return;
+        }
 
-    // console.warn("PointerDevice.start");
+        this.isRunning = true;
 
-    const domElement = this.domElement;
+        // console.warn("PointerDevice.start");
 
-    assert.notEqual(domElement, null, "domElement is null");
-    assert.notEqual(domElement, undefined, "domElement is undefined");
+        const domElement = this.domElement;
 
-    domElement.addEventListener(MouseEvents.Move, this.eventHandlerMouseMove);
-    domElement.addEventListener(MouseEvents.Up, this.eventHandlerMouseUp);
-    domElement.addEventListener(MouseEvents.Down, this.eventHandlerMouseDown);
+        assert.notEqual(domElement, null, "domElement is null");
+        assert.notEqual(domElement, undefined, "domElement is undefined");
 
-    domElement.addEventListener(TouchEvents.Start, this.eventHandlerTouchStart);
-    domElement.addEventListener(TouchEvents.End, this.eventHandlerTouchEnd);
-    domElement.addEventListener(TouchEvents.Move, this.eventHandlerTouchMove);
+        domElement.addEventListener(MouseEvents.Move, this.#eventHandlerMouseMove);
+        domElement.addEventListener(MouseEvents.Up, this.#eventHandlerMouseUp);
+        domElement.addEventListener(MouseEvents.Down, this.#eventHandlerMouseDown);
 
-    window.addEventListener(MouseEvents.Up, this.eventHandlerGlobalMouseUp);
-    window.addEventListener(TouchEvents.End, this.eventHandlerGlobalTouchEnd);
+        domElement.addEventListener(TouchEvents.Start, this.#eventHandlerTouchStart);
+        domElement.addEventListener(TouchEvents.End, this.#eventHandlerTouchEnd);
+        domElement.addEventListener(TouchEvents.Move, this.#eventHandlerTouchMove);
 
-    /*
-    In some cases wheel event gets registered as "passive" by default. This interferes with "preventDefault()"
-    see https://www.chromestatus.com/features/6662647093133312
-     */
-    domElement.addEventListener(MouseEvents.Wheel, this.eventHandlerWheel, { passive: false });
+        window.addEventListener(MouseEvents.Up, this.#eventHandlerGlobalMouseUp);
+        window.addEventListener(TouchEvents.End, this.#eventHandlerGlobalTouchEnd);
 
+        /*
+        In some cases wheel event gets registered as "passive" by default. This interferes with "preventDefault()"
+        see https://www.chromestatus.com/features/6662647093133312
+         */
+        domElement.addEventListener(MouseEvents.Wheel, this.#eventHandlerWheel, { passive: false });
 
-    domElement.addEventListener("contextmenu", supressContextMenu);
-};
 
-PointerDevice.prototype.stop = function () {
-    if (!this.isRunning) {
-        //not running
-        return;
+        domElement.addEventListener("contextmenu", supressContextMenu);
     }
 
-    this.isRunning = false;
+    stop() {
+        if (!this.isRunning) {
+            //not running
+            return;
+        }
 
-    // console.warn("PointerDevice.stop");
+        this.isRunning = false;
 
-    const domElement = this.domElement;
+        // console.warn("PointerDevice.stop");
 
-    domElement.removeEventListener(MouseEvents.Move, this.eventHandlerMouseMove);
-    domElement.removeEventListener(MouseEvents.Up, this.eventHandlerMouseUp);
-    domElement.removeEventListener(MouseEvents.Down, this.eventHandlerMouseDown);
+        const domElement = this.domElement;
 
-    domElement.removeEventListener(TouchEvents.Start, this.eventHandlerTouchStart);
-    domElement.removeEventListener(TouchEvents.End, this.eventHandlerTouchEnd);
-    domElement.removeEventListener(TouchEvents.Move, this.eventHandlerTouchMove);
+        domElement.removeEventListener(MouseEvents.Move, this.#eventHandlerMouseMove);
+        domElement.removeEventListener(MouseEvents.Up, this.#eventHandlerMouseUp);
+        domElement.removeEventListener(MouseEvents.Down, this.#eventHandlerMouseDown);
 
-    window.removeEventListener(MouseEvents.Up, this.eventHandlerGlobalMouseUp);
-    window.removeEventListener(TouchEvents.End, this.eventHandlerGlobalTouchEnd);
+        domElement.removeEventListener(TouchEvents.Start, this.#eventHandlerTouchStart);
+        domElement.removeEventListener(TouchEvents.End, this.#eventHandlerTouchEnd);
+        domElement.removeEventListener(TouchEvents.Move, this.#eventHandlerTouchMove);
 
-    domElement.removeEventListener(MouseEvents.Wheel, this.eventHandlerWheel);
+        window.removeEventListener(MouseEvents.Up, this.#eventHandlerGlobalMouseUp);
+        window.removeEventListener(TouchEvents.End, this.#eventHandlerGlobalTouchEnd);
 
+        domElement.removeEventListener(MouseEvents.Wheel, this.#eventHandlerWheel);
 
-    domElement.removeEventListener("contextmenu", supressContextMenu);
-};
+
+        domElement.removeEventListener("contextmenu", supressContextMenu);
+    }
+}
 
 const KeyboardEvents = {
     KeyUp: 'keyup',
@@ -96881,7 +96954,7 @@ const KeyboardEvents = {
 /**
  * Representation of an input device key
  */
-class InputDeviceButton {
+class InputDeviceSwitch {
     /**
      * Button press
      * @type {Signal}
@@ -96938,7 +97011,28 @@ function isFocusable(el) {
         || isInstanceOf(el, HTMLAreaElement)
 }
 
+/**
+ * @readonly
+ * @type {string[]}
+ */
+const codeToKeyNameMap = [];
+
 class KeyboardDevice {
+
+    /**
+     * @readonly
+     */
+    on = {
+        down: new Signal(),
+        up: new Signal()
+    };
+
+    /**
+     * @readonly
+     * @type {Object<InputDeviceSwitch>}
+     */
+    keys = {};
+
     /**
      *
      * @param {EventTarget|Element} domElement
@@ -96958,19 +97052,6 @@ class KeyboardDevice {
          */
         this.domElement = domElement;
 
-        this.on = {
-            down: new Signal(),
-            up: new Signal()
-        };
-
-
-        /**
-         *
-         * @type {Object<InputDeviceButton>}
-         */
-        const keys = this.keys = {};
-
-        const codeToKeyNameMap = [];
 
         //initialize separate events for each key
         for (let keyName in KeyCodes) {
@@ -96979,51 +97060,61 @@ class KeyboardDevice {
 
             codeToKeyNameMap[keyCode] = keyName;
 
-            keys[keyName] = new InputDeviceButton();
+            this.keys[keyName] = new InputDeviceSwitch();
         }
 
-        this.__handlerKeyDown = (event) => {
-            this.on.down.send1(event);
+    }
 
-            //hook up dispatch handler for individual keys
-            const keyCode = event.keyCode;
-            const keyName = codeToKeyNameMap[keyCode];
+    /**
+     *
+     * @param {KeyboardEvent} event
+     * @private
+     */
+    #handlerKeyDown = (event) => {
+        this.on.down.send1(event);
 
-            if (keyName !== undefined) {
-                const button = keys[keyName];
+        //hook up dispatch handler for individual keys
+        const keyCode = event.keyCode;
+        const keyName = codeToKeyNameMap[keyCode];
 
-                button.is_down = true;
-                button.down.send1(event);
+        if (keyName !== undefined) {
+            const button = this.keys[keyName];
 
-            }
-        };
+            button.is_down = true;
+            button.down.send1(event);
+
+        }
+    }
 
-        this.__handlerKeyUp = (event) => {
-            this.on.up.send1(event);
+    /**
+     *
+     * @param {KeyboardEvent} event
+     * @private
+     */
+    #handlerKeyUp = (event) => {
+        this.on.up.send1(event);
 
-            //hook up dispatch handler for individual keys
-            const keyCode = event.keyCode;
+        //hook up dispatch handler for individual keys
+        const keyCode = event.keyCode;
 
-            const keyName = codeToKeyNameMap[keyCode];
+        const keyName = codeToKeyNameMap[keyCode];
 
-            if (keyName !== undefined) {
-                const button = keys[keyName];
+        if (keyName !== undefined) {
+            const button = this.keys[keyName];
 
-                button.is_down = false;
-                button.up.send1(event);
-            }
-        };
+            button.is_down = false;
+            button.up.send1(event);
+        }
     }
 
-
     start() {
-        this.domElement.addEventListener(KeyboardEvents.KeyDown, this.__handlerKeyDown);
-        this.domElement.addEventListener(KeyboardEvents.KeyUp, this.__handlerKeyUp);
+        this.domElement.addEventListener(KeyboardEvents.KeyDown, this.#handlerKeyDown);
+        this.domElement.addEventListener(KeyboardEvents.KeyUp, this.#handlerKeyUp);
     }
 
     stop() {
-        this.domElement.removeEventListener(KeyboardEvents.KeyDown, this.__handlerKeyDown);
-        this.domElement.removeEventListener(KeyboardEvents.KeyUp, this.__handlerKeyUp);
+        this.domElement.removeEventListener(KeyboardEvents.KeyDown, this.#handlerKeyDown);
+        this.domElement.removeEventListener(KeyboardEvents.KeyUp, this.#handlerKeyUp);
     }
 }
 
@@ -118741,7 +118832,11 @@ AbstractLight.prototype.type = 'Abstract';
  * @param {number[]|Float32Array|Float64Array} aabb_corners
  * @param {number[]|Float32Array|mat4} projection_matrix
  */
-function aabb3_matrix4_project_by_corners(result, aabb_corners, projection_matrix) {
+function aabb3_matrix4_project_by_corners(
+    result,
+    aabb_corners,
+    projection_matrix
+) {
     assert.greaterThanOrEqual(result.length, 6, 'result.length must >= 6');
     assert.greaterThanOrEqual(aabb_corners.length, 24, 'aabb_corners.length must >= 24');
     assert.greaterThanOrEqual(projection_matrix.length, 16, 'projection_matrix.length must >= 16');
@@ -118844,6 +118939,11 @@ class Decal extends AbstractLight {
         this.transform_inverse = new Float32Array(16);
         this.uv = new Float32Array(4);
 
+        this.color = new Float32Array(4);
+        // initialize color to full white
+        this.color.fill(1);
+
+
         /**
          *
          * @type {Sampler2D}
@@ -118923,8 +119023,11 @@ class Decal extends AbstractLight {
         array_copy(this.uv, 0, destination, address + 16, 4);
 
         // required for sorting
-        destination[address + 20] = this.draw_priority;
-        destination[address + 21] = this.id;
+        // destination[address + 20] = this.draw_priority;
+        // destination[address + 21] = this.id;
+
+        // color
+        array_copy(this.color, 0, destination, address + 20, 4);
 
         return 24;
     }
@@ -119456,11 +119559,7 @@ function point_light_inside_volume(
     }
 }
 
-/**
- *
- * @type {number[]}
- */
-const stack = [];
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
@@ -119485,7 +119584,7 @@ function frustum_check(data_view, address, planes) {
         const plane_normal_z = planes[plane_address + 2];
         const plane_constant = planes[plane_address + 3];
 
-        const distanceAbovePlane = aabb3_computeDistanceAbovePlane_max(
+        const distanceAbovePlane = aabb3_compute_distance_above_plane_max(
             plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
             n_x0, n_y0, n_z0,
             n_x1, n_y1, n_z1
@@ -119522,8 +119621,6 @@ function query_bvh_frustum_from_texture(
     source_data,
     planes, points
 ) {
-
-    let stackPointer = 1;
     let result = 0;
 
     const binary_node_count = root.getBinaryNodeCount();
@@ -119533,19 +119630,26 @@ function query_bvh_frustum_from_texture(
         return 0;
     }
 
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
     /**
      * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
      * @type {number}
      */
-    stack[0] = 0;
+    stack[stack_top] = 0;
 
     const last_valid_index = binary_node_count + root.getLeafNodeCount();
     const data_view = root.getDataView();
 
-    while (stackPointer-- > 0) {
+    do {
+        stack.pointer--;
 
         // query_bvh_frustum_from_objects.iteration_count++;
-        const node_index = stack[stackPointer];
+        const node_index = stack[stack.pointer];
 
         if (node_index < binary_node_count) {
             // is intermediate node
@@ -119560,11 +119664,11 @@ function query_bvh_frustum_from_texture(
 
             // left node ends up on top of the stack, which aligns with the desired access sequence
             if (right_index < last_valid_index) {
-                stack[stackPointer++] = right_index;
+                stack[stack.pointer++] = right_index;
                 // micro-optimization, since we know that right node is valid and left appears before that, left is valid too
-                stack[stackPointer++] = left_index;
+                stack[stack.pointer++] = left_index;
             } else if (left_index < last_valid_index) {
-                stack[stackPointer++] = left_index;
+                stack[stack.pointer++] = left_index;
             }
 
 
@@ -119612,7 +119716,7 @@ function query_bvh_frustum_from_texture(
             result++;
         }
 
-    }
+    }while (stack.pointer > stack_top)
 
     return result;
 }
@@ -120861,14 +120965,17 @@ class LightManager {
         assert.isNumber(x, 'x');
         assert.isNonNegativeInteger(x, 'x');
         assert.isFiniteNumber(x, 'x');
+        assert.greaterThan(x,0,'x must be > 0');
 
         assert.isNumber(y, 'y');
         assert.isNonNegativeInteger(y, 'y');
         assert.isFiniteNumber(y, 'y');
+        assert.greaterThan(y,0,'y must be > 0');
 
         assert.isNumber(z, 'z');
         assert.isNonNegativeInteger(z, 'z');
         assert.isFiniteNumber(z, 'z');
+        assert.greaterThan(z,0,'z must be > 0');
 
         const r = this.__tiles_resolution;
 
@@ -121210,6 +121317,10 @@ const FP_SHADER_CHUNK_APPLY_DECALS = `
                             
             vec4 decal_color = texture2D(fp_t_decal_atlas,decal_uv, -0.2);
             
+            vec4 decal_color_tint = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address+5u), 0);
+            
+            decal_color*= decal_color_tint;
+            
             // compute decal alpha
             float decal_alpha = decal_color.a * decal_surface_angle_fade;