@woosh/meep-engine 2.34.40 → 2.34.44

package/core/bvh2/aabb3/AABB3.js

@@ -6,941 +6,937 @@
 import { aabb3_computeDistanceAbovePlane } from "../../geom/3d/aabb/aabb3_computeDistanceAbovePlane.js";
 import { computeAABB3PlaneSide } from "../../geom/3d/aabb/computeAABB3PlaneSide.js";
 import computeMortonCode from "../../geom/3d/morton/Morton.js";
-import { boxSurfaceArea, intersectRay, intersectSegment } from "./AABB3Math.js";
 import { aabb3_build_corners } from "../../geom/3d/aabb/aabb3_build_corners.js";
 import { assert } from "../../assert.js";
 import { aabb3_intersects_frustum_degree } from "./aabb3_intersects_frustum_degree.js";
-
-
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @constructor
- */
-function AABB3(
-    x0 = 0,
-    y0 = 0,
-    z0 = 0,
-    x1 = 0,
-    y1 = 0,
-    z1 = 0
-) {
-    this.setBounds(x0, y0, z0, x1, y1, z1);
-    this._surfaceArea = -1;
-}
-
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @returns {boolean}
- */
-AABB3.prototype.containsPoint = function (x, y, z) {
-    return x >= this.x0
-        && x <= this.x1
-        && y >= this.y0
-        && y <= this.y1
-        && z >= this.z0
-        && z <= this.z1;
-};
-
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @param {number} tolerance
- * @returns {boolean}
- */
-AABB3.prototype.containsPointWithTolerance = function (x, y, z, tolerance) {
-    if (
-        (x + tolerance) < this.x0 || (x - tolerance) > this.x1
-        || (y + tolerance) < this.y0 || (y - tolerance) > this.y1
-        || (z + tolerance) < this.z0 || (z - tolerance) > this.z1
+import { aabb3_intersects_frustum } from "./aabb3_intersects_frustum_array.js";
+import { aabb3_intersects_line_segment } from "./aabb3_intersects_line_segment.js";
+import { aabb3_intersects_ray } from "./aabb3_intersects_ray.js";
+import { aabb3_compute_surface_area } from "./aabb3_compute_surface_area.js";
+
+
+export class AABB3 {
+    /**
+     *
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} z0
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} z1
+     * @constructor
+     */
+    constructor(
+        x0 = 0,
+        y0 = 0,
+        z0 = 0,
+        x1 = 0,
+        y1 = 0,
+        z1 = 0
     ) {
-        return false;
-    }
-
-    return true;
-};
-
-AABB3.prototype.computeMortonCode = function () {
-    const cx = (this.x0 + this.x1) >> 1;
-    const cy = (this.y0 + this.y1) >> 1;
-    const cz = (this.z0 + this.z1) >> 1;
-    return computeMortonCode(cx, cy, cz);
-};
-
-/**
- *
- * @returns {number}
- */
-AABB3.prototype.computeSurfaceArea = function () {
-    return boxSurfaceArea(this.x0, this.y0, this.z0, this.x1, this.y1, this.z1);
-};
+        this.setBounds(x0, y0, z0, x1, y1, z1);
+        this._surfaceArea = -1;
+    }
+
+    /**
+     *
+     * @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;
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} tolerance
+     * @returns {boolean}
+     */
+    containsPointWithTolerance(x, y, z, tolerance) {
+        if (
+            (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;
+        }
 
-/**
- *
- * @returns {number}
- */
-AABB3.prototype.getSurfaceArea = function () {
-    if (typeof this._surfaceArea !== "number" || this._surfaceArea <= 0) {
-        this._surfaceArea = this.computeSurfaceArea();
+        return true;
     }
-    return this._surfaceArea;
-};
-
-/**
- *
- * @returns {number}
- */
-AABB3.prototype.computeVolume = function () {
-    return this.getExtentsX() * this.getExtentsY() * this.getExtentsZ();
-}
-
-/**
- *
- * @param {AABB3} other
- */
-AABB3.prototype.copy = function (other) {
-    this.setBounds(other.x0, other.y0, other.z0, other.x1, other.y1, other.z1);
-};
-
-/**
- *
- * @param {Number} x0
- * @param {Number} y0
- * @param {Number} z0
- * @param {Number} x1
- * @param {Number} y1
- * @param {Number} z1
- */
-AABB3.prototype.setBounds = function (x0, y0, z0, x1, y1, z1) {
-    this.x0 = x0;
-    this.y0 = y0;
-    this.z0 = z0;
-    this.x1 = x1;
-    this.y1 = y1;
-    this.z1 = z1;
-};
-
-/**
- *
- * @param {AABB3} other
- * @returns {boolean}
- */
-AABB3.prototype.equals = function (other) {
-    return this._equals(other.x0, other.y0, other.z0, other.x1, other.y1, other.z1);
-};
-
-/**
- *
- * @param {Number} x0
- * @param {Number} y0
- * @param {Number} z0
- * @param {Number} x1
- * @param {Number} y1
- * @param {Number} z1
- * @returns {boolean}
- */
-AABB3.prototype._equals = function (x0, y0, z0, x1, y1, z1) {
-    return this.x0 === x0 && this.y0 === y0 && this.z0 === z0 && this.x1 === x1 && this.y1 === y1 && this.z1 === z1;
-};
-
-/**
- * Same as setBounds, but does not require component pairs to be ordered (e.g. x0 <= x1). Method will enforce the correct order and invoke setBounds internally
- * @param {Number} x0
- * @param {Number} y0
- * @param {Number} z0
- * @param {Number} x1
- * @param {Number} y1
- * @param {Number} z1
- */
-AABB3.prototype.setBoundsUnordered = function (x0, y0, z0, x1, y1, z1) {
-    let _x0, _y0, _z0, _x1, _y1, _z1;
-    if (x0 < x1) {
-        _x0 = x0;
-        _x1 = x1;
-    } else {
-        _x0 = x1;
-        _x1 = x0;
-    }
-    if (y0 < y1) {
-        _y0 = y0;
-        _y1 = y1;
-    } else {
-        _y0 = y1;
-        _y1 = y0;
-    }
-    if (z0 < z1) {
-        _z0 = z0;
-        _z1 = z1;
-    } else {
-        _z0 = z1;
-        _z1 = z0;
-    }
-    this.setBounds(_x0, _y0, _z0, _x1, _y1, _z1);
-};
-
-AABB3.prototype.setNegativelyInfiniteBounds = function () {
-    this.setBounds(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY);
-};
-
-AABB3.prototype.setInfiniteBounds = function () {
-    this.setBounds(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
-};
-
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @returns {number} Squared distance to point, value is negative if the point is inside the box
- */
-AABB3.prototype.distanceToPoint2 = function (x, y, z) {
-    const _x0 = this.x0;
-    const _y0 = this.y0;
-    const _z0 = this.z0;
-    const _x1 = this.x1;
-    const _y1 = this.y1;
-    const _z1 = this.z1;
-
-    //do projection
-    const xp0 = _x0 - x;
-    const xp1 = x - _x1;
-    const yp0 = _y0 - y;
-    const yp1 = y - _y1;
-    const zp0 = _z0 - z;
-    const zp1 = z - _z1;
-
-    //calculate separation in each axis
-    const dx = Math.max(xp0, xp1);
-    const dy = Math.max(yp0, yp1);
-    const dz = Math.max(zp0, zp1);
-
-    //straight-line distance
-    const distance2 = dx * dx + dy * dy + dz * dz;
-
-    if (dx < 0 && dy < 0 && dz < 0) {
-        //penetration
-        return -distance2;
-    } else {
-        return distance2;
-    }
-};
-
-/**
- *
- * @param {AABB3} box
- * @returns {number}
- */
-AABB3.prototype.distanceToBox = function (box) {
-    return this._distanceToBox(box.x0, box.y0, box.z0, box.x1, box.y1, box.z1);
-};
-
-/**
- * Computes separation distance between two boxes.
- * If poxes penetrate or one is inside another - the result will be negative.
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @returns {number}
- */
-AABB3.prototype._distanceToBox = function (x0, y0, z0, x1, y1, z1) {
-    const _x0 = this.x0;
-    const _y0 = this.y0;
-    const _z0 = this.z0;
-    const _x1 = this.x1;
-    const _y1 = this.y1;
-    const _z1 = this.z1;
-
-    //do projection
-    const xp0 = _x0 - x1;
-    const xp1 = x0 - _x1;
-    const yp0 = _y0 - y1;
-    const yp1 = y0 - _y1;
-    const zp0 = _z0 - z1;
-    const zp1 = z0 - _z1;
-
-    //calculate separation in each axis
-    const dx = Math.max(xp0, xp1);
-    const dy = Math.max(yp0, yp1);
-    const dz = Math.max(zp0, zp1);
-
-    //straight-line distance
-    let distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
-
-    if (dx < 0 && dy < 0 && dz < 0) {
-        //penetration
-        return -distance;
-    } else {
-        return distance;
-    }
-};
-
-/**
- *
- * @param {AABB3} other
- * @returns {number}
- */
-AABB3.prototype.costForInclusion = function (other) {
-    return this._costForInclusion(other.x0, other.y0, other.z0, other.x1, other.y1, other.z1);
-};
 
-/**
- * Surface area delta when including a given AABB
- * 0 means that including a given AABB would not cause any change to total surface area
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @returns {number}
- */
-AABB3.prototype._costForInclusion = function (x0, y0, z0, x1, y1, z1) {
-    let x = 0;
-    let y = 0;
-    let z = 0;
-    //
-    const _x0 = this.x0;
-    const _y0 = this.y0;
-    const _z0 = this.z0;
-    const _x1 = this.x1;
-    const _y1 = this.y1;
-    const _z1 = this.z1;
-    //
-    if (_x0 > x0) {
-        x += _x0 - x0;
-    }
-    if (_x1 < x1) {
-        x += x1 - _x1;
-    }
-    if (_y0 > y0) {
-        y += _y0 - y0;
-    }
-    if (_y1 < y1) {
-        y += y1 - _y1;
-    }
-    if (_z0 > z0) {
-        z += _z0 - z0;
+    computeMortonCode() {
+        const cx = (this.x0 + this.x1) >> 1;
+        const cy = (this.y0 + this.y1) >> 1;
+        const cz = (this.z0 + this.z1) >> 1;
+        return computeMortonCode(cx, cy, cz);
     }
-    if (_z1 < z1) {
-        z += z1 - _z1;
-    }
-
-    const dx = _x1 - _x0;
-    const dy = _y1 - _y0;
-    const dz = _z1 - _z0;
-
-    return (x * (dy + dz) + y * (dx + dz) + z * (dx + dy));
-};
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @returns {boolean}
- */
-AABB3.prototype._expandToFitPoint = function (x, y, z) {
-    let expanded = false;
-    if (x < this.x0) {
-        this.x0 = x;
-        expanded = true;
+    /**
+     *
+     * @returns {number}
+     */
+    computeSurfaceArea() {
+        return aabb3_compute_surface_area(this.x0, this.y0, this.z0, this.x1, this.y1, this.z1);
     }
-    if (y < this.y0) {
-        this.y0 = y;
-        expanded = true;
-    }
-    if (z < this.z0) {
-        this.z0 = z;
-        expanded = true;
-    }
-    if (x > this.x1) {
-        this.x1 = x;
-        expanded = true;
-    }
-    if (y > this.y1) {
-        this.y1 = y;
-        expanded = true;
-    }
-    if (z > this.z1) {
-        this.z1 = z;
-        expanded = true;
-    }
-    return expanded;
-};
 
-/**
- *
- * @param {AABB3} box
- * @returns {boolean}
- */
-AABB3.prototype.expandToFit = function (box) {
-    return this._expandToFit(box.x0, box.y0, box.z0, box.x1, box.y1, box.z1);
-};
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @returns {boolean}
- */
-AABB3.prototype._expandToFit = function (x0, y0, z0, x1, y1, z1) {
-    let expanded = false;
-    if (x0 < this.x0) {
+    /**
+     *
+     * @returns {number}
+     */
+    getSurfaceArea() {
+        if (typeof this._surfaceArea !== "number" || this._surfaceArea <= 0) {
+            this._surfaceArea = this.computeSurfaceArea();
+        }
+        return this._surfaceArea;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    computeVolume() {
+        return this.getExtentsX() * this.getExtentsY() * this.getExtentsZ();
+    }
+
+    /**
+     *
+     * @param {AABB3} other
+     */
+    copy(other) {
+        this.setBounds(other.x0, other.y0, other.z0, other.x1, other.y1, other.z1);
+    }
+
+    /**
+     *
+     * @param {Number} x0
+     * @param {Number} y0
+     * @param {Number} z0
+     * @param {Number} x1
+     * @param {Number} y1
+     * @param {Number} z1
+     */
+    setBounds(x0, y0, z0, x1, y1, z1) {
         this.x0 = x0;
-        expanded = true;
-    }
-    if (y0 < this.y0) {
         this.y0 = y0;
-        expanded = true;
-    }
-    if (z0 < this.z0) {
         this.z0 = z0;
-        expanded = true;
-    }
-    if (x1 > this.x1) {
         this.x1 = x1;
-        expanded = true;
-    }
-    if (y1 > this.y1) {
         this.y1 = y1;
-        expanded = true;
-    }
-    if (z1 > this.z1) {
         this.z1 = z1;
-        expanded = true;
     }
-    return expanded;
-};
 
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @returns {boolean}
- */
-AABB3.prototype._containsBox = function (x0, y0, z0, x1, y1, z1) {
-    return x0 >= this.x0 && y0 >= this.y0 && z0 >= this.z0 && x1 <= this.x1 && y1 <= this.y1 && z1 <= this.z1;
-};
-
-/**
- *
- * @param {AABB3} box
- * @returns {boolean}
- */
-AABB3.prototype.containsBox = function (box) {
-    return this._containsBox(box.x0, box.y0, box.z0, box.x1, box.y1, box.z1);
-};
-
-/**
- *
- * @returns {number}
- */
-AABB3.prototype.getExtentsX = function () {
-    return (this.x1 - this.x0);
-};
-/**
- *
- * @returns {number}
- */
-AABB3.prototype.getExtentsY = function () {
-    return (this.y1 - this.y0);
-};
-/**
- *
- * @returns {number}
- */
-AABB3.prototype.getExtentsZ = function () {
-    return (this.z1 - this.z0);
-};
-
-/**
- * half-width in X axis
- * @returns {number}
- */
-AABB3.prototype.getHalfExtentsX = function () {
-    return this.getExtentsX() / 2;
-};
-/**
- * half-width in Y axis
- * @returns {number}
- */
-AABB3.prototype.getHalfExtentsY = function () {
-    return this.getExtentsY() / 2;
-};
-/**
- * half-width in Z axis
- * @returns {number}
- */
-AABB3.prototype.getHalfExtentsZ = function () {
-    return this.getExtentsZ() / 2;
-};
-
-/**
- * Get center position of the box
- * @param {Vector3} target where to write result
- */
-AABB3.prototype.getCenter = function (target) {
-    const x = (this.x0 + this.x1) / 2;
-    const y = (this.y0 + this.y1) / 2;
-    const z = (this.z0 + this.z1) / 2;
-    target.set(x, y, z);
-};
-
-/**
- *
- * @param {Vector3} target
- */
-AABB3.prototype.getExtents = function (target) {
-    const x = (this.x1 - this.x0);
-    const y = (this.y1 - this.y0);
-    const z = (this.z1 - this.z0);
+    /**
+     *
+     * @param {AABB3} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this._equals(other.x0, other.y0, other.z0, other.x1, other.y1, other.z1);
+    }
+
+    /**
+     *
+     * @param {Number} x0
+     * @param {Number} y0
+     * @param {Number} z0
+     * @param {Number} x1
+     * @param {Number} y1
+     * @param {Number} z1
+     * @returns {boolean}
+     */
+    _equals(x0, y0, z0, x1, y1, z1) {
+        return this.x0 === x0 && this.y0 === y0 && this.z0 === z0 && this.x1 === x1 && this.y1 === y1 && this.z1 === z1;
+    }
+
+    /**
+     * Same as setBounds, but does not require component pairs to be ordered (e.g. x0 <= x1). Method will enforce the correct order and invoke setBounds internally
+     * @param {Number} x0
+     * @param {Number} y0
+     * @param {Number} z0
+     * @param {Number} x1
+     * @param {Number} y1
+     * @param {Number} z1
+     */
+    setBoundsUnordered(x0, y0, z0, x1, y1, z1) {
+        let _x0, _y0, _z0, _x1, _y1, _z1;
+        if (x0 < x1) {
+            _x0 = x0;
+            _x1 = x1;
+        } else {
+            _x0 = x1;
+            _x1 = x0;
+        }
+        if (y0 < y1) {
+            _y0 = y0;
+            _y1 = y1;
+        } else {
+            _y0 = y1;
+            _y1 = y0;
+        }
+        if (z0 < z1) {
+            _z0 = z0;
+            _z1 = z1;
+        } else {
+            _z0 = z1;
+            _z1 = z0;
+        }
+        this.setBounds(_x0, _y0, _z0, _x1, _y1, _z1);
+    }
+
+    setNegativelyInfiniteBounds() {
+        this.setBounds(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY);
+    }
+
+    setInfiniteBounds() {
+        this.setBounds(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {number} Squared distance to point, value is negative if the point is inside the box
+     */
+    distanceToPoint2(x, y, z) {
+        const _x0 = this.x0;
+        const _y0 = this.y0;
+        const _z0 = this.z0;
+        const _x1 = this.x1;
+        const _y1 = this.y1;
+        const _z1 = this.z1;
+
+        //do projection
+        const xp0 = _x0 - x;
+        const xp1 = x - _x1;
+        const yp0 = _y0 - y;
+        const yp1 = y - _y1;
+        const zp0 = _z0 - z;
+        const zp1 = z - _z1;
+
+        //calculate separation in each axis
+        const dx = Math.max(xp0, xp1);
+        const dy = Math.max(yp0, yp1);
+        const dz = Math.max(zp0, zp1);
+
+        //straight-line distance
+        const distance2 = dx * dx + dy * dy + dz * dz;
+
+        if (dx < 0 && dy < 0 && dz < 0) {
+            //penetration
+            return -distance2;
+        } else {
+            return distance2;
+        }
+    }
 
-    target.set(x, y, z);
-};
+    /**
+     *
+     * @param {AABB3} box
+     * @returns {number}
+     */
+    distanceToBox(box) {
+        return this._distanceToBox(box.x0, box.y0, box.z0, box.x1, box.y1, box.z1);
+    }
+
+    /**
+     * Computes separation distance between two boxes.
+     * If poxes penetrate or one is inside another - the result will be negative.
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} z0
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} z1
+     * @returns {number}
+     */
+    _distanceToBox(x0, y0, z0, x1, y1, z1) {
+        const _x0 = this.x0;
+        const _y0 = this.y0;
+        const _z0 = this.z0;
+        const _x1 = this.x1;
+        const _y1 = this.y1;
+        const _z1 = this.z1;
+
+        //do projection
+        const xp0 = _x0 - x1;
+        const xp1 = x0 - _x1;
+        const yp0 = _y0 - y1;
+        const yp1 = y0 - _y1;
+        const zp0 = _z0 - z1;
+        const zp1 = z0 - _z1;
+
+        //calculate separation in each axis
+        const dx = Math.max(xp0, xp1);
+        const dy = Math.max(yp0, yp1);
+        const dz = Math.max(zp0, zp1);
+
+        //straight-line distance
+        let distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+
+        if (dx < 0 && dy < 0 && dz < 0) {
+            //penetration
+            return -distance;
+        } else {
+            return distance;
+        }
+    }
 
-/**
- * Accepts ray description, first set of coordinates is origin (oX,oY,oZ) and second is direction (dX,dY,dZ). Algorithm from GraphicsGems by Andrew Woo
- * @param oX
- * @param oY
- * @param oZ
- * @param dX
- * @param dY
- * @param dZ
- */
-AABB3.prototype.intersectRay = function (oX, oY, oZ, dX, dY, dZ) {
-    return intersectRay(this.x0, this.y0, this.z0, this.x1, this.y1, this.z1, oX, oY, oZ, dX, dY, dZ);
-};
+    /**
+     *
+     * @param {AABB3} other
+     * @returns {number}
+     */
+    costForInclusion(other) {
+        return this._costForInclusion(other.x0, other.y0, other.z0, other.x1, other.y1, other.z1);
+    }
+
+    /**
+     * Surface area delta when including a given AABB
+     * 0 means that including a given AABB would not cause any change to total surface area
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} z0
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} z1
+     * @returns {number}
+     */
+    _costForInclusion(x0, y0, z0, x1, y1, z1) {
+        let x = 0;
+        let y = 0;
+        let z = 0;
+        //
+        const _x0 = this.x0;
+        const _y0 = this.y0;
+        const _z0 = this.z0;
+        const _x1 = this.x1;
+        const _y1 = this.y1;
+        const _z1 = this.z1;
+        //
+        if (_x0 > x0) {
+            x += _x0 - x0;
+        }
+        if (_x1 < x1) {
+            x += x1 - _x1;
+        }
+        if (_y0 > y0) {
+            y += _y0 - y0;
+        }
+        if (_y1 < y1) {
+            y += y1 - _y1;
+        }
+        if (_z0 > z0) {
+            z += _z0 - z0;
+        }
+        if (_z1 < z1) {
+            z += z1 - _z1;
+        }
 
-AABB3.prototype.intersectSegment = function (startX, startY, startZ, endX, endY, endZ) {
-    return intersectSegment(this.x0, this.y0, this.z0, this.x1, this.y1, this.z1, startX, startY, startZ, endX, endY, endZ);
-};
-/**
- * @source http://stackoverflow.com/questions/3106666/intersection-of-line-segment-with-axis-aligned-box-in-c-sharp
- * @param startX
- * @param startY
- * @param startZ
- * @param endX
- * @param endY
- * @param endZ
- * @returns {boolean}
- */
-AABB3.prototype.intersectSegment2 = function (startX, startY, startZ, endX, endY, endZ) {
-    //var beginToEnd = segmentEnd - segmentBegin;
-    const deltaX = endX - startX,
-        deltaY = endY - startY,
-        deltaZ = endZ - startZ;
-    //var minToMax = new Vector3D(boxSize.X, boxSize.Y, boxSize.Z);
-
-    //var min = boxCenter - minToMax / 2;
-    //var max = boxCenter + minToMax / 2;
-    //var beginToMin = min - segmentBegin;
-    //var beginToMax = max - segmentBegin;
-    //var tNear = double.MinValue;
-    let tNear = Number.NEGATIVE_INFINITY;
-    //var tFar = double.MaxValue;
-    let tFar = Number.POSITIVE_INFINITY;
-    let t1, t2, tMin, tMax;
-    //var intersections = new List<Point3D>();
-    //var intersections = [];
-    let beginToMin = this.x0 - startX;
-    let beginToMax = this.x1 - startX;
-    if (deltaX === 0) {//parallel
-        if (beginToMin > 0 || beginToMax < 0) {
-            return false; //segment is not between planes
+        const dx = _x1 - _x0;
+        const dy = _y1 - _y0;
+        const dz = _z1 - _z0;
+
+        return (x * (dy + dz) + y * (dx + dz) + z * (dx + dy));
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {boolean}
+     */
+    _expandToFitPoint(x, y, z) {
+        let expanded = false;
+        if (x < this.x0) {
+            this.x0 = x;
+            expanded = true;
         }
-    } else {
-        t1 = beginToMin / deltaX;
-        t2 = beginToMax / deltaX;
-        tMin = Math.min(t1, t2);
-        tMax = Math.max(t1, t2);
-        if (tMin > tNear) {
-            tNear = tMin;
+        if (y < this.y0) {
+            this.y0 = y;
+            expanded = true;
         }
-        if (tMax < tFar) {
-            tFar = tMax;
+        if (z < this.z0) {
+            this.z0 = z;
+            expanded = true;
         }
-        if (tNear > tFar || tFar < 0) {
-            return false;
+        if (x > this.x1) {
+            this.x1 = x;
+            expanded = true;
         }
-    }
-    beginToMin = this.y0 - startY;
-    beginToMax = this.y1 - startY;
-    if (deltaY === 0) {//parallel
-        if (beginToMin > 0 || beginToMax < 0) {
-            return false; //segment is not between planes
+        if (y > this.y1) {
+            this.y1 = y;
+            expanded = true;
         }
-    } else {
-        t1 = beginToMin / deltaY;
-        t2 = beginToMax / deltaY;
-        tMin = Math.min(t1, t2);
-        tMax = Math.max(t1, t2);
-        if (tMin > tNear) {
-            tNear = tMin;
+        if (z > this.z1) {
+            this.z1 = z;
+            expanded = true;
         }
-        if (tMax < tFar) {
-            tFar = tMax;
+        return expanded;
+    }
+
+    /**
+     *
+     * @param {AABB3} box
+     * @returns {boolean}
+     */
+    expandToFit(box) {
+        return this._expandToFit(box.x0, box.y0, box.z0, box.x1, box.y1, box.z1);
+    }
+
+    /**
+     *
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} z0
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} z1
+     * @returns {boolean}
+     */
+    _expandToFit(x0, y0, z0, x1, y1, z1) {
+        let expanded = false;
+        if (x0 < this.x0) {
+            this.x0 = x0;
+            expanded = true;
         }
-        if (tNear > tFar || tFar < 0) {
-            return false;
+        if (y0 < this.y0) {
+            this.y0 = y0;
+            expanded = true;
         }
-    }
-    beginToMin = this.z0 - startZ;
-    beginToMax = this.z1 - startZ;
-    if (deltaZ === 0) {//parallel
-        if (beginToMin > 0 || beginToMax < 0) {
-            return false; //segment is not between planes
+        if (z0 < this.z0) {
+            this.z0 = z0;
+            expanded = true;
         }
-    } else {
-        t1 = beginToMin / deltaZ;
-        t2 = beginToMax / deltaZ;
-        tMin = Math.min(t1, t2);
-        tMax = Math.max(t1, t2);
-        if (tMin > tNear) {
-            tNear = tMin;
+        if (x1 > this.x1) {
+            this.x1 = x1;
+            expanded = true;
         }
-        if (tMax < tFar) {
-            tFar = tMax;
+        if (y1 > this.y1) {
+            this.y1 = y1;
+            expanded = true;
         }
-        if (tNear > tFar || tFar < 0) {
-            return false;
+        if (z1 > this.z1) {
+            this.z1 = z1;
+            expanded = true;
+        }
+        return expanded;
+    }
+
+    /**
+     *
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} z0
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} z1
+     * @returns {boolean}
+     */
+    _containsBox(x0, y0, z0, x1, y1, z1) {
+        return x0 >= this.x0 && y0 >= this.y0 && z0 >= this.z0 && x1 <= this.x1 && y1 <= this.y1 && z1 <= this.z1;
+    }
+
+    /**
+     *
+     * @param {AABB3} box
+     * @returns {boolean}
+     */
+    containsBox(box) {
+        return this._containsBox(box.x0, box.y0, box.z0, box.x1, box.y1, box.z1);
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    getExtentsX() {
+        return (this.x1 - this.x0);
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    getExtentsY() {
+        return (this.y1 - this.y0);
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    getExtentsZ() {
+        return (this.z1 - this.z0);
+    }
+
+    /**
+     * half-width in X axis
+     * @returns {number}
+     */
+    getHalfExtentsX() {
+        return this.getExtentsX() / 2;
+    }
+
+    /**
+     * half-width in Y axis
+     * @returns {number}
+     */
+    getHalfExtentsY() {
+        return this.getExtentsY() / 2;
+    }
+
+    /**
+     * half-width in Z axis
+     * @returns {number}
+     */
+    getHalfExtentsZ() {
+        return this.getExtentsZ() / 2;
+    }
+
+    /**
+     * Get center position of the box
+     * @param {Vector3} target where to write result
+     */
+    getCenter(target) {
+        const x = (this.x0 + this.x1) / 2;
+        const y = (this.y0 + this.y1) / 2;
+        const z = (this.z0 + this.z1) / 2;
+        target.set(x, y, z);
+    }
+
+    /**
+     *
+     * @param {Vector3} target
+     */
+    getExtents(target) {
+        const x = (this.x1 - this.x0);
+        const y = (this.y1 - this.y0);
+        const z = (this.z1 - this.z0);
+
+        target.set(x, y, z);
+    }
+
+    /**
+     * Accepts ray description, first set of coordinates is origin (oX,oY,oZ) and second is direction (dX,dY,dZ). Algorithm from GraphicsGems by Andrew Woo
+     * @param oX
+     * @param oY
+     * @param oZ
+     * @param dX
+     * @param dY
+     * @param dZ
+     */
+    intersectRay(oX, oY, oZ, dX, dY, dZ) {
+        return aabb3_intersects_ray(this.x0, this.y0, this.z0, this.x1, this.y1, this.z1, oX, oY, oZ, dX, dY, dZ);
+    }
+
+    intersectSegment(startX, startY, startZ, endX, endY, endZ) {
+        return aabb3_intersects_line_segment(this.x0, this.y0, this.z0, this.x1, this.y1, this.z1, startX, startY, startZ, endX, endY, endZ);
+    }
+
+    /**
+     * @source http://stackoverflow.com/questions/3106666/intersection-of-line-segment-with-axis-aligned-box-in-c-sharp
+     * @param startX
+     * @param startY
+     * @param startZ
+     * @param endX
+     * @param endY
+     * @param endZ
+     * @returns {boolean}
+     */
+    intersectSegment2(startX, startY, startZ, endX, endY, endZ) {
+        //var beginToEnd = segmentEnd - segmentBegin;
+        const deltaX = endX - startX,
+            deltaY = endY - startY,
+            deltaZ = endZ - startZ;
+        //var minToMax = new Vector3D(boxSize.X, boxSize.Y, boxSize.Z);
+
+        //var min = boxCenter - minToMax / 2;
+        //var max = boxCenter + minToMax / 2;
+        //var beginToMin = min - segmentBegin;
+        //var beginToMax = max - segmentBegin;
+        //var tNear = double.MinValue;
+        let tNear = Number.NEGATIVE_INFINITY;
+        //var tFar = double.MaxValue;
+        let tFar = Number.POSITIVE_INFINITY;
+        let t1, t2, tMin, tMax;
+        //var intersections = new List<Point3D>();
+        //var intersections = [];
+        let beginToMin = this.x0 - startX;
+        let beginToMax = this.x1 - startX;
+        if (deltaX === 0) {//parallel
+            if (beginToMin > 0 || beginToMax < 0) {
+                return false; //segment is not between planes
+            }
+        } else {
+            t1 = beginToMin / deltaX;
+            t2 = beginToMax / deltaX;
+            tMin = Math.min(t1, t2);
+            tMax = Math.max(t1, t2);
+            if (tMin > tNear) {
+                tNear = tMin;
+            }
+            if (tMax < tFar) {
+                tFar = tMax;
+            }
+            if (tNear > tFar || tFar < 0) {
+                return false;
+            }
+        }
+        beginToMin = this.y0 - startY;
+        beginToMax = this.y1 - startY;
+        if (deltaY === 0) {//parallel
+            if (beginToMin > 0 || beginToMax < 0) {
+                return false; //segment is not between planes
+            }
+        } else {
+            t1 = beginToMin / deltaY;
+            t2 = beginToMax / deltaY;
+            tMin = Math.min(t1, t2);
+            tMax = Math.max(t1, t2);
+            if (tMin > tNear) {
+                tNear = tMin;
+            }
+            if (tMax < tFar) {
+                tFar = tMax;
+            }
+            if (tNear > tFar || tFar < 0) {
+                return false;
+            }
+        }
+        beginToMin = this.z0 - startZ;
+        beginToMax = this.z1 - startZ;
+        if (deltaZ === 0) {//parallel
+            if (beginToMin > 0 || beginToMax < 0) {
+                return false; //segment is not between planes
+            }
+        } else {
+            t1 = beginToMin / deltaZ;
+            t2 = beginToMax / deltaZ;
+            tMin = Math.min(t1, t2);
+            tMax = Math.max(t1, t2);
+            if (tMin > tNear) {
+                tNear = tMin;
+            }
+            if (tMax < tFar) {
+                tFar = tMax;
+            }
+            if (tNear > tFar || tFar < 0) {
+                return false;
+            }
+        }
+        //
+        if (tNear >= 0 && tNear <= 1) {
+            //intersections.push({
+            //    x: startX + deltaX * tNear,
+            //    y: startY + deltaY * tNear,
+            //    z: startZ + deltaZ * tNear
+            //});
+            return true;
+        }
+        if (tFar >= 0 && tFar <= 1) {
+            //intersections.push({
+            //    x: startX + deltaX * tFar,
+            //    y: startY + deltaY * tFar,
+            //    z: startZ + deltaZ * tFar
+            //});
+            return true;
+        }
+        return false;
+        //foreach (Axis axis in Enum.GetValues(typeof(Axis)))
+        //{
+        //    if (beginToEnd.GetCoordinate(axis) == 0) // parallel
+        //    {
+        //        if (beginToMin.GetCoordinate(axis) > 0 || beginToMax.GetCoordinate(axis) < 0)
+        //            return intersections; // segment is not between planes
+        //    }
+        //    else
+        //    {
+        //        var t1 = beginToMin.GetCoordinate(axis) / beginToEnd.GetCoordinate(axis);
+        //        var t2 = beginToMax.GetCoordinate(axis) / beginToEnd.GetCoordinate(axis);
+        //        var tMin = Math.Min(t1, t2);
+        //        var tMax = Math.Max(t1, t2);
+        //        if (tMin > tNear) tNear = tMin;
+        //        if (tMax < tFar) tFar = tMax;
+        //        if (tNear > tFar || tFar < 0) return intersections;
+        //
+        //    }
+        //}
+        //if (tNear >= 0 && tNear <= 1) intersections.Add(segmentBegin + beginToEnd * tNear);
+        //if (tFar >= 0 && tFar <= 1) intersections.Add(segmentBegin + beginToEnd * tFar);
+        //return intersections;
+    }
+
+    /**
+     *
+     * @param {THREE.Box} box
+     * @returns {boolean}
+     */
+    threeContainsBox(box) {
+        const min = box.min;
+        const max = box.max;
+        return this._containsBox(min.x, min.y, min.z, max.x, max.y, max.z);
+    }
+
+    /**
+     *
+     * @param {function(x:number, y:number, z:number)} callback
+     * @param {*} [thisArg]
+     */
+    traverseCorners(callback, thisArg) {
+        const _x0 = this.x0;
+        const _y0 = this.y0;
+        const _z0 = this.z0;
+        const _x1 = this.x1;
+        const _y1 = this.y1;
+        const _z1 = this.z1;
+
+        callback.call(thisArg, _x0, _y0, _z0);
+        callback.call(thisArg, _x0, _y0, _z1);
+
+        callback.call(thisArg, _x0, _y1, _z0);
+        callback.call(thisArg, _x0, _y1, _z1);
+
+        callback.call(thisArg, _x1, _y0, _z0);
+        callback.call(thisArg, _x1, _y0, _z1);
+
+        callback.call(thisArg, _x1, _y1, _z0);
+        callback.call(thisArg, _x1, _y1, _z1);
+    }
+
+    /**
+     *
+     * @param {number[]|Float64Array|Float32Array} result
+     */
+    getCorners(result) {
+        aabb3_build_corners(
+            result,
+            0,
+            this.x0,
+            this.y0,
+            this.z0,
+            this.x1,
+            this.y1,
+            this.z1
+        );
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array|Float64Array} result
+     * @param {number} offset
+     */
+    writeToArray(result, offset) {
+        assert.isNonNegativeInteger(offset, 'offset');
+
+        result[offset] = this.x0;
+        result[offset + 1] = this.y0;
+        result[offset + 2] = this.z0;
+
+        result[offset + 3] = this.x1;
+        result[offset + 4] = this.y1;
+        result[offset + 5] = this.z1;
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array|Float64Array} source
+     * @param {number} offset
+     */
+    readFromArray(source, offset) {
+        assert.isNonNegativeInteger(offset, 'offset');
+
+        this.x0 = source[offset];
+        this.y0 = source[offset + 1];
+        this.z0 = source[offset + 2];
+
+        this.x1 = source[offset + 3];
+        this.y1 = source[offset + 4];
+        this.z1 = source[offset + 5];
+    }
+
+    /**
+     * @param {THREE.Plane} plane
+     * @returns {int} 2,0,or -2; 2: above, -2 : below, 0 : intersects plane
+     */
+    computePlaneSide(plane) {
+        const normal = plane.normal;
+
+        return computeAABB3PlaneSide(
+            normal.x, normal.y, normal.z, plane.constant,
+            this.x0, this.y0, this.z0,
+            this.x1, this.y1, this.z1
+        );
+    }
+
+    /**
+     *
+     * @param {number} normal_x
+     * @param {number} normal_y
+     * @param {number} normal_z
+     * @param {number} offset
+     * @returns {number}
+     */
+    computeDistanceAbovePlane(normal_x, normal_y, normal_z, offset) {
+        return aabb3_computeDistanceAbovePlane(
+            normal_x, normal_y, normal_z, offset,
+            this.x0, this.y0, this.z0,
+            this.x1, this.y1, this.z1
+        );
+    }
+
+    /**
+     *
+     * @param {number} normal_x
+     * @param {number} normal_y
+     * @param {number} normal_z
+     * @param {number} offset
+     * @returns {boolean}
+     */
+    _isBelowPlane(normal_x, normal_y, normal_z, offset) {
+        return this.computeDistanceAbovePlane(normal_x, normal_y, normal_z, offset) < 0;
+    }
+
+    /**
+     *
+     * @param {Plane} plane
+     * @return {boolean}
+     */
+    isBelowPlane(plane) {
+        const normal = plane.normal;
+
+        return this._isBelowPlane(normal.x, normal.y, normal.z, plane.constant);
+    }
+
+    /**
+     *
+     * @param {Plane[]} clippingPlanes
+     * @returns {boolean}
+     */
+    intersectSpace(clippingPlanes) {
+        let i = 0;
+        const l = clippingPlanes.length;
+        for (; i < l; i++) {
+
+            const plane = clippingPlanes[i];
+            if (this.isBelowPlane(plane)) {
+                return false;
+            }
         }
-    }
-    //
-    if (tNear >= 0 && tNear <= 1) {
-        //intersections.push({
-        //    x: startX + deltaX * tNear,
-        //    y: startY + deltaY * tNear,
-        //    z: startZ + deltaZ * tNear
-        //});
-        return true;
-    }
-    if (tFar >= 0 && tFar <= 1) {
-        //intersections.push({
-        //    x: startX + deltaX * tFar,
-        //    y: startY + deltaY * tFar,
-        //    z: startZ + deltaZ * tFar
-        //});
         return true;
     }
-    return false;
-    //foreach (Axis axis in Enum.GetValues(typeof(Axis)))
-    //{
-    //    if (beginToEnd.GetCoordinate(axis) == 0) // parallel
-    //    {
-    //        if (beginToMin.GetCoordinate(axis) > 0 || beginToMax.GetCoordinate(axis) < 0)
-    //            return intersections; // segment is not between planes
-    //    }
-    //    else
-    //    {
-    //        var t1 = beginToMin.GetCoordinate(axis) / beginToEnd.GetCoordinate(axis);
-    //        var t2 = beginToMax.GetCoordinate(axis) / beginToEnd.GetCoordinate(axis);
-    //        var tMin = Math.Min(t1, t2);
-    //        var tMax = Math.Max(t1, t2);
-    //        if (tMin > tNear) tNear = tMin;
-    //        if (tMax < tFar) tFar = tMax;
-    //        if (tNear > tFar || tFar < 0) return intersections;
-    //
-    //    }
-    //}
-    //if (tNear >= 0 && tNear <= 1) intersections.Add(segmentBegin + beginToEnd * tNear);
-    //if (tFar >= 0 && tFar <= 1) intersections.Add(segmentBegin + beginToEnd * tFar);
-    //return intersections;
-};
-
-/**
- *
- * @param {THREE.Box} box
- * @returns {boolean}
- */
-AABB3.prototype.threeContainsBox = function (box) {
-    const min = box.min;
-    const max = box.max;
-    return this._containsBox(min.x, min.y, min.z, max.x, max.y, max.z);
-};
-
-/**
- *
- * @param {function(x:number, y:number, z:number)} callback
- * @param {*} [thisArg]
- */
-AABB3.prototype.traverseCorners = function (callback, thisArg) {
-    const _x0 = this.x0;
-    const _y0 = this.y0;
-    const _z0 = this.z0;
-    const _x1 = this.x1;
-    const _y1 = this.y1;
-    const _z1 = this.z1;
-
-    callback.call(thisArg, _x0, _y0, _z0);
-    callback.call(thisArg, _x0, _y0, _z1);
-
-    callback.call(thisArg, _x0, _y1, _z0);
-    callback.call(thisArg, _x0, _y1, _z1);
-
-    callback.call(thisArg, _x1, _y0, _z0);
-    callback.call(thisArg, _x1, _y0, _z1);
-
-    callback.call(thisArg, _x1, _y1, _z0);
-    callback.call(thisArg, _x1, _y1, _z1);
-};
-
-/**
- *
- * @param {number[]|Float64Array|Float32Array} result
- */
-AABB3.prototype.getCorners = function (result) {
-    aabb3_build_corners(
-        result,
-        0,
-        this.x0,
-        this.y0,
-        this.z0,
-        this.x1,
-        this.y1,
-        this.z1
-    );
-};
-
-/**
- *
- * @param {number[]|Float32Array|Float64Array} result
- * @param {number} offset
- */
-AABB3.prototype.writeToArray = function (result, offset) {
-    assert.isNonNegativeInteger(offset, 'offset');
-
-    result[offset] = this.x0;
-    result[offset + 1] = this.y0;
-    result[offset + 2] = this.z0;
-
-    result[offset + 3] = this.x1;
-    result[offset + 4] = this.y1;
-    result[offset + 5] = this.z1;
-};
-
-/**
- *
- * @param {number[]|Float32Array|Float64Array} source
- * @param {number} offset
- */
-AABB3.prototype.readFromArray = function (source, offset) {
-    assert.isNonNegativeInteger(offset, 'offset');
 
-    this.x0 = source[offset];
-    this.y0 = source[offset + 1];
-    this.z0 = source[offset + 2];
-
-    this.x1 = source[offset + 3];
-    this.y1 = source[offset + 4];
-    this.z1 = source[offset + 5];
-};
-
-/**
- * @param {THREE.Plane} plane
- * @returns {int} 2,0,or -2; 2: above, -2 : below, 0 : intersects plane
- */
-AABB3.prototype.computePlaneSide = function computePlaneSide(plane) {
-    const normal = plane.normal;
-
-    return computeAABB3PlaneSide(
-        normal.x, normal.y, normal.z, plane.constant,
-        this.x0, this.y0, this.z0,
-        this.x1, this.y1, this.z1
-    );
-};
-
-/**
- *
- * @param {number} normal_x
- * @param {number} normal_y
- * @param {number} normal_z
- * @param {number} offset
- * @returns {number}
- */
-AABB3.prototype.computeDistanceAbovePlane = function (normal_x, normal_y, normal_z, offset) {
-    return aabb3_computeDistanceAbovePlane(
-        normal_x, normal_y, normal_z, offset,
-        this.x0, this.y0, this.z0,
-        this.x1, this.y1, this.z1
-    );
-};
-
-/**
- *
- * @param {number} normal_x
- * @param {number} normal_y
- * @param {number} normal_z
- * @param {number} offset
- * @returns {boolean}
- */
-AABB3.prototype._isBelowPlane = function (normal_x, normal_y, normal_z, offset) {
-    return this.computeDistanceAbovePlane(normal_x, normal_y, normal_z, offset) < 0;
-};
+    /**
+     *
+     * @param {Frustum} frustum
+     * @returns {number}
+     */
+    intersectFrustumDegree(frustum) {
+        const planes = frustum.planes;
 
-/**
- *
- * @param {Plane} plane
- * @return {boolean}
- */
-AABB3.prototype.isBelowPlane = function (plane) {
-    const normal = plane.normal;
+        let i = 0;
+        let result = 2;
+        for (; i < 6; i++) {
 
-    return this._isBelowPlane(normal.x, normal.y, normal.z, plane.constant);
-};
+            const plane = planes[i];
 
-/**
- *
- * @param {Plane[]} clippingPlanes
- * @returns {boolean}
- */
-AABB3.prototype.intersectSpace = function (clippingPlanes) {
-    let i = 0;
-    const l = clippingPlanes.length;
-    for (; i < l; i++) {
+            const planeSide = this.computePlaneSide(plane);
 
-        const plane = clippingPlanes[i];
-        if (this.isBelowPlane(plane)) {
-            return false;
+            if (planeSide < 0) {
+                return 0;
+            } else if (planeSide === 0) {
+                result = 1;
+            }
         }
-    }
-    return true;
-};
-
-/**
- *
- * @param {Frustum} frustum
- * @returns {number}
- */
-AABB3.prototype.intersectFrustumDegree = function (frustum) {
-    const planes = frustum.planes;
-
-    let i = 0;
-    let result = 2;
-    for (; i < 6; i++) {
-
-        const plane = planes[i];
-
-        const planeSide = this.computePlaneSide(plane);
-
-        if (planeSide < 0) {
-            return 0;
-        } else if (planeSide === 0) {
-            result = 1;
+        return result;
+    }
+
+    /**
+     *
+     * @param {number[]} frustum
+     * @returns {number}
+     */
+    intersectFrustumDegree_array(frustum) {
+        return aabb3_intersects_frustum_degree(
+            this.x0, this.y0, this.z0, this.x1, this.y1, this.z1, frustum
+        );
+    }
+
+    /**
+     *
+     * @param {{planes:Array}}frustum
+     * @returns {boolean}
+     */
+    intersectFrustum(frustum) {
+        const planes = frustum.planes;
+        for (let i = 0; i < 6; i++) {
+
+            const plane = planes[i];
+            if (this.isBelowPlane(plane)) {
+                return false;
+            }
         }
+        return true;
     }
-    return result;
-};
-/**
- *
- * @param {number[]} frustum
- * @returns {number}
- */
-AABB3.prototype.intersectFrustumDegree_array = function (frustum) {
-    return aabb3_intersects_frustum_degree(
-        this.x0, this.y0, this.z0, this.x1, this.y1, this.z1, frustum
-    );
-};
-
-/**
- *
- * @param {{planes:Array}}frustum
- * @returns {boolean}
- */
-AABB3.prototype.intersectFrustum = function intersectFrustum(frustum) {
-    const planes = frustum.planes;
-    for (let i = 0; i < 6; i++) {
 
-        const plane = planes[i];
-        if (this.isBelowPlane(plane)) {
-            return false;
-        }
-    }
-    return true;
-};
+    /**
+     *
+     * @param {ArrayLike<number>|number[]|Float32Array}frustum
+     * @returns {boolean}
+     */
+    intersectFrustum_array(frustum) {
+        const x0 = this.x0;
+        const y0 = this.y0;
+        const z0 = this.z0;
 
-/**
- *
- * @param {ArrayLike<number>|number[]|Float32Array}frustum
- * @returns {boolean}
- */
-AABB3.prototype.intersectFrustum_array = function intersectFrustum(frustum) {
-    const x0 = this.x0;
-    const y0 = this.y0;
-    const z0 = this.z0;
-    const x1 = this.x1;
-    const y1 = this.y1;
-    const z1 = this.z1;
-
-    for (let i = 0; i < 24; i += 4) {
-
-        const p_nx = frustum[i];
-        const p_ny = frustum[i + 1];
-        const p_nz = frustum[i + 2];
-        const p_c = frustum[i + 3];
-
-        if (aabb3_computeDistanceAbovePlane(
-            p_nx, p_ny, p_nz, p_c,
-            x0, y0, z0,
-            x1, y1, z1
-        ) < 0) {
-            // below plane, i.e. outside of the frustum
-            return false;
-        }
+        const x1 = this.x1;
+        const y1 = this.y1;
+        const z1 = this.z1;
 
+        return aabb3_intersects_frustum(x0, y0, z0, x1, y1, z1, frustum);
     }
-    return true;
-};
 
+    /**
+     *
+     * @param {number} v
+     */
+    grow(v) {
+        this.x0 -= v;
+        this.y0 -= v;
+        this.z0 -= v;
 
-/**
- *
- * @param {number} v
- */
-AABB3.prototype.grow = function (v) {
-    this.x0 -= v;
-    this.y0 -= v;
-    this.z0 -= v;
+        this.x1 += v;
+        this.y1 += v;
+        this.z1 += v;
+    }
 
-    this.x1 += v;
-    this.y1 += v;
-    this.z1 += v;
-};
+    /**
+     *
+     * @returns {AABB3}
+     */
+    clone() {
+        const clone = new AABB3();
 
-/**
- *
- * @returns {AABB3}
- */
-AABB3.prototype.clone = function () {
-    const clone = new AABB3();
+        clone.copy(this);
 
-    clone.copy(this);
+        return clone;
+    }
 
-    return clone;
-};
+    fromJSON({ x0, y0, z0, x1, y1, z1 }) {
+        this.setBounds(x0, y0, z0, x1, y1, z1);
+    }
+}
 
-AABB3.prototype.fromJSON = function ({ x0, y0, z0, x1, y1, z1 }) {
-    this.setBounds(x0, y0, z0, x1, y1, z1);
-};
 
 /**
  *
@@ -1018,184 +1014,8 @@ export function serializeAABB3Encoded_v0(buffer, box, x0, y0, z0, x1, y1, z1) {
     }
 }
 
-
 /**
- *
- * @param {BinaryBuffer} buffer
- * @param {AABB3} box
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
+ * @readonly
+ * @type {boolean}
  */
-export function deserializeAABB3Encoded_v0(buffer, box, x0, y0, z0, x1, y1, z1) {
-    const header = buffer.readUint8();
-
-    //compute value ranges
-    const xD = x1 - x0;
-    const yD = y1 - y0;
-    const zD = z1 - z0;
-
-
-    let qx0;
-    let qx1;
-
-    let qy0;
-    let qy1;
-
-    let qz0;
-    let qz1;
-
-    if ((header & 1) === 0) {
-        const _x0 = buffer.readUint16();
-        qx0 = (_x0 / 65535) * xD + x0;
-    } else {
-        qx0 = x0;
-    }
-
-    if ((header & 2) === 0) {
-        const _x1 = buffer.readUint16();
-        qx1 = (_x1 / 65535) * xD + x0;
-    } else {
-        qx1 = x1;
-    }
-
-    if ((header & 4) === 0) {
-        const _y0 = buffer.readUint16();
-        qy0 = (_y0 / 65535) * yD + y0;
-    } else {
-        qy0 = y0;
-    }
-
-    if ((header & 8) === 0) {
-        const _y1 = buffer.readUint16();
-        qy1 = (_y1 / 65535) * yD + y0;
-    } else {
-        qy1 = y1;
-    }
-
-    if ((header & 16) === 0) {
-        const _z0 = buffer.readUint16();
-        qz0 = (_z0 / 65535) * zD + z0;
-    } else {
-        qz0 = z0;
-    }
-
-    if ((header & 32) === 0) {
-        const _z1 = buffer.readUint16();
-        qz1 = (_z1 / 65535) * zD + z0;
-    } else {
-        qz1 = z1;
-    }
-
-    box.setBounds(qx0, qy0, qz0, qx1, qy1, qz1);
-}
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {AABB3} box
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- */
-export function serializeAABB3Quantized16Uint(buffer, box, x0, y0, z0, x1, y1, z1) {
-    //compute value ranges
-    const xD = x1 - x0;
-    const yD = y1 - y0;
-    const zD = z1 - z0;
-
-    //quantize all values
-    const _x0 = (((box.x0 - x0) / xD) * 65535) | 0;
-    const _y0 = (((box.y0 - y0) / yD) * 65535) | 0;
-    const _z0 = (((box.z0 - z0) / zD) * 65535) | 0;
-
-    const _x1 = (((box.x1 - x0) / xD) * 65535) | 0;
-    const _y1 = (((box.y1 - y0) / yD) * 65535) | 0;
-    const _z1 = (((box.z1 - z0) / zD) * 65535) | 0;
-
-    buffer.writeUint16(_x0);
-    buffer.writeUint16(_y0);
-    buffer.writeUint16(_z0);
-    buffer.writeUint16(_x1);
-    buffer.writeUint16(_y1);
-    buffer.writeUint16(_z1);
-}
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {AABB3} box
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- */
-export function deserializeAABB3Quantized16Uint(buffer, box, x0, y0, z0, x1, y1, z1) {
-    //compute value ranges
-    const xD = x1 - x0;
-    const yD = y1 - y0;
-    const zD = z1 - z0;
-
-    //read values
-    const _x0 = buffer.readUint16();
-    const _y0 = buffer.readUint16();
-    const _z0 = buffer.readUint16();
-    const _x1 = buffer.readUint16();
-    const _y1 = buffer.readUint16();
-    const _z1 = buffer.readUint16();
-
-    //quantize all values
-    const qx0 = (_x0 / 65535) * xD + x0;
-    const qy0 = (_y0 / 65535) * yD + y0;
-    const qz0 = (_z0 / 65535) * zD + z0;
-
-    const qx1 = (_x1 / 65535) * xD + x0;
-    const qy1 = (_y1 / 65535) * yD + y0;
-    const qz1 = (_z1 / 65535) * zD + z0;
-
-    box.setBounds(qx0, qy0, qz0, qx1, qy1, qz1);
-}
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {AABB3} box
- */
-function serializeAABB3(buffer, box) {
-    buffer.writeFloat64(box.x0);
-    buffer.writeFloat64(box.y0);
-    buffer.writeFloat64(box.z0);
-    buffer.writeFloat64(box.x1);
-    buffer.writeFloat64(box.y1);
-    buffer.writeFloat64(box.z1);
-}
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {AABB3} box
- */
-function deserializeAABB3(buffer, box) {
-    const x0 = buffer.readFloat64();
-    const y0 = buffer.readFloat64();
-    const z0 = buffer.readFloat64();
-    const x1 = buffer.readFloat64();
-    const y1 = buffer.readFloat64();
-    const z1 = buffer.readFloat64();
-
-    box.setBounds(x0, y0, z0, x1, y1, z1);
-}
-
-export {
-    AABB3,
-    serializeAABB3,
-    deserializeAABB3
-};
+AABB3.prototype.isAABB3 = true;