@math.gl/geometry 5.0.0-alpha.2 → 5.0.0-alpha.20

package/src/culling/lib/bounding-volumes/axis-aligned-bounding-box.ts

@@ -0,0 +1,153 @@
+// math.gl
+// SPDX-License-Identifier: MIT AND Apache-2.0
+// SPDX-FileCopyrightText: Copyright 2011-2018 CesiumJS Contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Derived from Cesium. See the repository LICENSE for upstream attribution and Apache-2.0 terms.
+
+import {BoundingVolume} from './bounding-volume';
+import {Vector3} from '@math.gl/core';
+import {Plane} from '../plane';
+import type {CullingResult} from '../../constants';
+
+const scratchVector = new Vector3();
+const scratchNormal = new Vector3();
+
+/**
+ * An axis aligned bounding box - aligned with coordinate axes
+ * @see BoundingVolume
+ * @see BoundingRectangle
+ * @see OrientedBoundingBox
+ */
+export class AxisAlignedBoundingBox implements BoundingVolume {
+  /** The center point of the bounding box. */
+  readonly center: Vector3;
+  /** The positive half diagonal of the bounding box. */
+  readonly halfDiagonal: Vector3;
+  /** The minimum point defining the bounding box. [0, 0, 0] for empty box */
+  readonly minimum: Vector3;
+  /** The maximum point defining the bounding box. [0, 0, 0] for empty box */
+  readonly maximum: Vector3;
+
+  /**
+   * Creates an instance of an AxisAlignedBoundingBox from the minimum and maximum points along the x, y, and z axes.
+   * @param minimum=[0, 0, 0] The minimum point along the x, y, and z axes.
+   * @param maximum=[0, 0, 0] The maximum point along the x, y, and z axes.
+   * @param center The center of the box; automatically computed if not supplied.
+   */
+  constructor(
+    minimum: readonly number[] = [0, 0, 0],
+    maximum: readonly number[] = [0, 0, 0],
+    center?: readonly number[]
+  ) {
+    // If center was not defined, compute it.
+    center = center || scratchVector.copy(minimum).add(maximum).scale(0.5);
+    this.center = new Vector3(center);
+    this.halfDiagonal = new Vector3(maximum).subtract(this.center);
+
+    /**
+     * The minimum point defining the bounding box.
+     * @type {Vector3}
+     * @default {@link 0, 0, 0}
+     */
+    this.minimum = new Vector3(minimum);
+
+    /**
+     * The maximum point defining the bounding box.
+     * @type {Vector3}
+     * @default {@link 0, 0, 0}
+     */
+    this.maximum = new Vector3(maximum);
+  }
+
+  /**
+   * Duplicates a AxisAlignedBoundingBox instance.
+   *
+   * @returns {AxisAlignedBoundingBox} A new AxisAlignedBoundingBox instance.
+   */
+  clone(): AxisAlignedBoundingBox {
+    return new AxisAlignedBoundingBox(this.minimum, this.maximum, this.center);
+  }
+
+  /**
+   * Compares the provided AxisAlignedBoundingBox componentwise and returns
+   * <code>true</code> if they are equal, <code>false</code> otherwise.
+   *
+   * @param {AxisAlignedBoundingBox} [right] The second AxisAlignedBoundingBox to compare with.
+   * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+   */
+  equals(right: AxisAlignedBoundingBox): boolean {
+    return (
+      this === right ||
+      (Boolean(right) && this.minimum.equals(right.minimum) && this.maximum.equals(right.maximum))
+    );
+  }
+
+  /**
+   * Applies a 4x4 affine transformation matrix to a bounding sphere.
+   * @param transform The transformation matrix to apply to the bounding sphere.
+   * @returns itself, i.e. the modified BoundingVolume.
+   */
+  transform(transform: readonly number[]): this {
+    this.center.transformAsPoint(transform);
+    // TODO - this.halfDiagonal.transformAsVector(transform);
+    this.halfDiagonal.transform(transform);
+    this.minimum.transform(transform);
+    this.maximum.transform(transform);
+    return this;
+  }
+
+  /**
+   * Determines which side of a plane a box is located.
+   */
+  intersectPlane(plane: Plane): CullingResult {
+    const {halfDiagonal} = this;
+    const normal = scratchNormal.from(plane.normal);
+    const e =
+      halfDiagonal.x * Math.abs(normal.x) +
+      halfDiagonal.y * Math.abs(normal.y) +
+      halfDiagonal.z * Math.abs(normal.z);
+    const s = this.center.dot(normal) + plane.distance; // signed distance from center
+
+    if (s - e > 0) {
+      return 'inside';
+    }
+
+    if (s + e < 0) {
+      // Not in front because normals point inward
+      return 'outside';
+    }
+
+    return 'intersecting';
+  }
+
+  /** Computes the estimated distance from the closest point on a bounding box to a point. */
+  distanceTo(point: readonly number[]): number {
+    return Math.sqrt(this.distanceSquaredTo(point));
+  }
+
+  /** Computes the estimated distance squared from the closest point on a bounding box to a point. */
+  distanceSquaredTo(point: readonly number[]): number {
+    const offset = scratchVector.from(point).subtract(this.center);
+    const {halfDiagonal} = this;
+
+    let distanceSquared = 0.0;
+    let d;
+
+    d = Math.abs(offset.x) - halfDiagonal.x;
+    if (d > 0) {
+      distanceSquared += d * d;
+    }
+
+    d = Math.abs(offset.y) - halfDiagonal.y;
+    if (d > 0) {
+      distanceSquared += d * d;
+    }
+
+    d = Math.abs(offset.z) - halfDiagonal.z;
+    if (d > 0) {
+      distanceSquared += d * d;
+    }
+
+    return distanceSquared;
+  }
+}

package/src/culling/lib/bounding-volumes/bounding-sphere.ts

@@ -0,0 +1,154 @@
+// math.gl
+// SPDX-License-Identifier: MIT AND Apache-2.0
+// SPDX-FileCopyrightText: Copyright 2011-2018 CesiumJS Contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Derived from Cesium. See the repository LICENSE for upstream attribution and Apache-2.0 terms.
+
+// This file is derived from the Cesium math library under Apache 2 license
+// See ../../../../LICENSE for the retained Cesium notice and Apache-2.0 terms.
+
+import {NumericArray, Vector3} from '@math.gl/core';
+import * as mat4 from '@math.gl/core/mat4';
+
+import type {CullingResult} from '../../constants';
+import {BoundingVolume} from './bounding-volume';
+import {Plane} from '../plane';
+
+const scratchVector = new Vector3();
+const scratchVector2 = new Vector3();
+
+/** A BoundingSphere */
+export class BoundingSphere implements BoundingVolume {
+  center: Vector3;
+  radius: number;
+
+  /** Creates a bounding sphere */
+  constructor(center: readonly number[] = [0, 0, 0], radius: number = 0.0) {
+    this.radius = -0;
+    this.center = new Vector3();
+    this.fromCenterRadius(center, radius);
+  }
+
+  /** Sets the bounding sphere from `center` and `radius`. */
+  fromCenterRadius(center: readonly number[], radius: number): this {
+    this.center.from(center);
+    this.radius = radius;
+    return this;
+  }
+
+  /**
+   * Computes a bounding sphere from the corner points of an axis-aligned bounding box.  The sphere
+   * tightly and fully encompasses the box.
+   */
+  fromCornerPoints(corner: readonly number[], oppositeCorner: readonly number[]): this {
+    oppositeCorner = scratchVector.from(oppositeCorner);
+    this.center = new Vector3().from(corner).add(oppositeCorner).scale(0.5);
+    this.radius = this.center.distance(oppositeCorner);
+    return this;
+  }
+
+  /** Compares the provided BoundingSphere component wise */
+  equals(right: BoundingSphere): boolean {
+    return (
+      this === right ||
+      (Boolean(right) && this.center.equals(right.center) && this.radius === right.radius)
+    );
+  }
+
+  /** Duplicates a BoundingSphere instance. */
+  clone(): BoundingSphere {
+    return new BoundingSphere(this.center, this.radius);
+  }
+
+  /** Computes a bounding sphere that contains both the left and right bounding spheres. */
+  union(boundingSphere: BoundingSphere): BoundingSphere {
+    const leftCenter = this.center;
+    const leftRadius = this.radius;
+    const rightCenter = boundingSphere.center;
+    const rightRadius = boundingSphere.radius;
+
+    const toRightCenter = scratchVector.copy(rightCenter).subtract(leftCenter);
+    const centerSeparation = toRightCenter.magnitude();
+
+    if (leftRadius >= centerSeparation + rightRadius) {
+      // Left sphere wins.
+      return this.clone();
+    }
+
+    if (rightRadius >= centerSeparation + leftRadius) {
+      // Right sphere wins.
+      return boundingSphere.clone();
+    }
+
+    // There are two tangent points, one on far side of each sphere.
+    const halfDistanceBetweenTangentPoints = (leftRadius + centerSeparation + rightRadius) * 0.5;
+
+    // Compute the center point halfway between the two tangent points.
+    scratchVector2
+      .copy(toRightCenter)
+      .scale((-leftRadius + halfDistanceBetweenTangentPoints) / centerSeparation)
+      .add(leftCenter);
+
+    this.center.copy(scratchVector2);
+    this.radius = halfDistanceBetweenTangentPoints;
+
+    return this;
+  }
+
+  /** Computes a bounding sphere by enlarging the provided sphere to contain the provided point. */
+  expand(point: readonly number[]): this {
+    const scratchPoint = scratchVector.from(point);
+    const radius = scratchPoint.subtract(this.center).magnitude();
+    if (radius > this.radius) {
+      this.radius = radius;
+    }
+    return this;
+  }
+
+  // BoundingVolume interface
+
+  /**
+   * Applies a 4x4 affine transformation matrix to a bounding sphere.
+   * @param sphere The bounding sphere to apply the transformation to.
+   * @param transform The transformation matrix to apply to the bounding sphere.
+   * @returns self.
+   */
+  transform(transform: readonly number[]): this {
+    this.center.transform(transform);
+    const scale = mat4.getScaling(scratchVector, transform);
+    this.radius = Math.max(scale[0], Math.max(scale[1], scale[2])) * this.radius;
+    return this;
+  }
+
+  /** Computes the estimated distance squared from the closest point on a bounding sphere to a point. */
+  distanceSquaredTo(point: Readonly<NumericArray>): number {
+    const d = this.distanceTo(point);
+    return d * d;
+  }
+
+  /** Computes the estimated distance from the closest point on a bounding sphere to a point. */
+  distanceTo(point: Readonly<NumericArray>): number {
+    const scratchPoint = scratchVector.from(point);
+    const delta = scratchPoint.subtract(this.center);
+    return Math.max(0, delta.len() - this.radius);
+  }
+
+  /** Determines which side of a plane a sphere is located. */
+  intersectPlane(plane: Plane): CullingResult {
+    const center = this.center;
+    const radius = this.radius;
+    const normal = plane.normal;
+    const distanceToPlane = normal.dot(center) + plane.distance;
+
+    // The center point is negative side of the plane normal
+    if (distanceToPlane < -radius) {
+      return 'outside';
+    }
+    // The center point is positive side of the plane, but radius extends beyond it; partial overlap
+    if (distanceToPlane < radius) {
+      return 'intersecting';
+    }
+    // The center point and radius is positive side of the plane
+    return 'inside';
+  }
+}

package/src/culling/lib/bounding-volumes/bounding-volume.ts

@@ -0,0 +1,38 @@
+// math.gl
+// SPDX-License-Identifier: MIT AND Apache-2.0
+// SPDX-FileCopyrightText: Copyright 2011-2018 CesiumJS Contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Derived from Cesium. See the repository LICENSE for upstream attribution and Apache-2.0 terms.
+
+import {Plane} from '../plane';
+import type {CullingResult} from '../../constants';
+
+/**
+ * Common interface for BoundingVolumes
+ * including BoundingSphere, AxisAlignedBoundingBox and OrientedBoundingBox
+ */
+export interface BoundingVolume {
+  /**
+   * Applies a 4x4 affine transformation matrix to a bounding sphere.
+   * @param sphere The bounding sphere to apply the transformation to.
+   * @param transform The transformation matrix to apply to the bounding sphere.
+   * @returns itself, i.e. the modified BoundingVolume.
+   */
+  transform(transform: readonly number[]): this;
+
+  /** Computes the estimated distance squared from the closest point on a bounding sphere to a point. */
+  distanceSquaredTo(point: readonly number[]): number;
+  /** Computes the estimated distance from the closest point on a bounding sphere to a point. */
+  distanceTo(point: readonly number[]): number;
+
+  /**
+   * Determines which side of a plane the oriented bounding box is located.
+   *
+   * @param plane The plane to test against.
+   * @returns
+   *  - `'inside'` if the entire box is on the side of the plane the normal is pointing.
+   *  - `'outside'` if the entire box is on the opposite side.
+   *  - `'intersecting'` if the box intersects the plane.
+   */
+  intersectPlane(plane: Plane): CullingResult;
+}

package/src/culling/lib/bounding-volumes/oriented-bounding-box.ts

@@ -0,0 +1,320 @@
+// math.gl
+// SPDX-License-Identifier: MIT AND Apache-2.0
+// SPDX-FileCopyrightText: Copyright 2011-2018 CesiumJS Contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Derived from Cesium. See the repository LICENSE for upstream attribution and Apache-2.0 terms.
+
+// This file is derived from the Cesium math library under Apache 2 license
+// See ../../../../LICENSE for the retained Cesium notice and Apache-2.0 terms.
+
+import {NumericArray} from '@math.gl/core/types';
+import {Vector3, Matrix3, Matrix4} from '@math.gl/core';
+
+import type {BoundingVolume} from './bounding-volume';
+import {BoundingSphere} from './bounding-sphere';
+import {Plane} from '../plane';
+import type {CullingResult} from '../../constants';
+
+const scratchVector3 = new Vector3();
+const scratchOffset = new Vector3();
+const scratchVectorU = new Vector3();
+const scratchVectorV = new Vector3();
+const scratchVectorW = new Vector3();
+const scratchCorner = new Vector3();
+const scratchToCenter = new Vector3();
+
+const MATRIX3 = {
+  COLUMN0ROW0: 0,
+  COLUMN0ROW1: 1,
+  COLUMN0ROW2: 2,
+  COLUMN1ROW0: 3,
+  COLUMN1ROW1: 4,
+  COLUMN1ROW2: 5,
+  COLUMN2ROW0: 6,
+  COLUMN2ROW1: 7,
+  COLUMN2ROW2: 8
+};
+
+/**
+ * An OrientedBoundingBox of some object is a closed and convex cuboid.
+ * It can provide a tighter bounding volume than `BoundingSphere` or
+ * `AxisAlignedBoundingBox` in many cases.
+ */
+export class OrientedBoundingBox implements BoundingVolume {
+  center: Vector3;
+  halfAxes: Matrix3;
+
+  /**
+   * An OrientedBoundingBox of some object is a closed and convex cuboid.
+   * It can provide a tighter bounding volume than
+   * `BoundingSphere` or `AxisAlignedBoundingBox` in many cases.
+   */
+  constructor(center?: Readonly<NumericArray>, halfAxes?: Readonly<NumericArray>);
+  constructor(
+    center: Readonly<NumericArray> = [0, 0, 0],
+    halfAxes: Readonly<NumericArray> = [0, 0, 0, 0, 0, 0, 0, 0, 0]
+  ) {
+    this.center = new Vector3().from(center);
+    this.halfAxes = new Matrix3(halfAxes);
+  }
+
+  /** Returns an array with three halfSizes for the bounding box */
+  get halfSize(): number[] {
+    const xAxis = this.halfAxes.getColumn(0);
+    const yAxis = this.halfAxes.getColumn(1);
+    const zAxis = this.halfAxes.getColumn(2);
+    return [new Vector3(xAxis).len(), new Vector3(yAxis).len(), new Vector3(zAxis).len()];
+  }
+
+  /** Duplicates a OrientedBoundingBox instance. */
+  clone(): OrientedBoundingBox {
+    return new OrientedBoundingBox(this.center, this.halfAxes);
+  }
+
+  /** Compares the provided OrientedBoundingBox component wise and returns */
+  equals(right: OrientedBoundingBox): boolean {
+    return (
+      this === right ||
+      (Boolean(right) && this.center.equals(right.center) && this.halfAxes.equals(right.halfAxes))
+    );
+  }
+
+  /** Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box. */
+  getBoundingSphere(result = new BoundingSphere()): BoundingSphere {
+    const halfAxes = this.halfAxes;
+    const u = halfAxes.getColumn(0, scratchVectorU);
+    const v = halfAxes.getColumn(1, scratchVectorV);
+    const w = halfAxes.getColumn(2, scratchVectorW);
+
+    // Calculate "corner" vector
+    const cornerVector = scratchVector3.copy(u).add(v).add(w);
+
+    result.center.copy(this.center);
+    result.radius = cornerVector.magnitude();
+
+    return result;
+  }
+
+  /** Determines which side of a plane the oriented bounding box is located. */
+  intersectPlane(plane: Plane): CullingResult {
+    const center = this.center;
+    const normal = plane.normal;
+    const halfAxes = this.halfAxes;
+
+    const normalX = normal.x;
+    const normalY = normal.y;
+    const normalZ = normal.z;
+
+    // Plane is used as if it is its normal; the first three components are assumed to be normalized
+    const radEffective =
+      Math.abs(
+        normalX * halfAxes[MATRIX3.COLUMN0ROW0] +
+          normalY * halfAxes[MATRIX3.COLUMN0ROW1] +
+          normalZ * halfAxes[MATRIX3.COLUMN0ROW2]
+      ) +
+      Math.abs(
+        normalX * halfAxes[MATRIX3.COLUMN1ROW0] +
+          normalY * halfAxes[MATRIX3.COLUMN1ROW1] +
+          normalZ * halfAxes[MATRIX3.COLUMN1ROW2]
+      ) +
+      Math.abs(
+        normalX * halfAxes[MATRIX3.COLUMN2ROW0] +
+          normalY * halfAxes[MATRIX3.COLUMN2ROW1] +
+          normalZ * halfAxes[MATRIX3.COLUMN2ROW2]
+      );
+    const distanceToPlane = normal.dot(center) + plane.distance;
+
+    if (distanceToPlane <= -radEffective) {
+      // The entire box is on the negative side of the plane normal
+      return 'outside';
+    } else if (distanceToPlane >= radEffective) {
+      // The entire box is on the positive side of the plane normal
+      return 'inside';
+    }
+    return 'intersecting';
+  }
+
+  /** Computes the estimated distance from the closest point on a bounding box to a point. */
+  distanceTo(point: readonly number[]): number {
+    return Math.sqrt(this.distanceSquaredTo(point));
+  }
+
+  /**
+   * Computes the estimated distance squared from the closest point
+   * on a bounding box to a point.
+   * See Geometric Tools for Computer Graphics 10.4.2
+   */
+  distanceSquaredTo(point: readonly number[]): number {
+    // Computes the estimated distance squared from the
+    // closest point on a bounding box to a point.
+    // See Geometric Tools for Computer Graphics 10.4.2
+    const offset = scratchOffset.from(point).subtract(this.center);
+
+    const halfAxes = this.halfAxes;
+    const u = halfAxes.getColumn(0, scratchVectorU);
+    const v = halfAxes.getColumn(1, scratchVectorV);
+    const w = halfAxes.getColumn(2, scratchVectorW);
+
+    const uHalf = u.magnitude();
+    const vHalf = v.magnitude();
+    const wHalf = w.magnitude();
+
+    u.normalize();
+    v.normalize();
+    w.normalize();
+
+    let distanceSquared = 0.0;
+    let d;
+
+    d = Math.abs(offset.dot(u)) - uHalf;
+    if (d > 0) {
+      distanceSquared += d * d;
+    }
+
+    d = Math.abs(offset.dot(v)) - vHalf;
+    if (d > 0) {
+      distanceSquared += d * d;
+    }
+
+    d = Math.abs(offset.dot(w)) - wHalf;
+    if (d > 0) {
+      distanceSquared += d * d;
+    }
+
+    return distanceSquared;
+  }
+
+  /**
+   * The distances calculated by the vector from the center of the bounding box
+   * to position projected onto direction.
+   *
+   * - If you imagine the infinite number of planes with normal direction,
+   *   this computes the smallest distance to the closest and farthest planes
+   *   from `position` that intersect the bounding box.
+   *
+   * @param position The position to calculate the distance from.
+   * @param direction The direction from position.
+   * @param result An Interval (array of length 2) to store the nearest and farthest distances.
+   * @returns Interval (array of length 2) with nearest and farthest distances
+   *   on the bounding box from position in direction.
+   */
+  // eslint-disable-next-line max-statements
+  computePlaneDistances(
+    position: readonly number[],
+    direction: Vector3,
+    result: number[] = [-0, -0]
+  ): number[] {
+    let minDist = Number.POSITIVE_INFINITY;
+    let maxDist = Number.NEGATIVE_INFINITY;
+
+    const center = this.center;
+    const halfAxes = this.halfAxes;
+
+    const u = halfAxes.getColumn(0, scratchVectorU);
+    const v = halfAxes.getColumn(1, scratchVectorV);
+    const w = halfAxes.getColumn(2, scratchVectorW);
+
+    // project first corner
+    const corner = scratchCorner.copy(u).add(v).add(w).add(center);
+
+    const toCenter = scratchToCenter.copy(corner).subtract(position);
+    let mag = direction.dot(toCenter);
+
+    minDist = Math.min(mag, minDist);
+    maxDist = Math.max(mag, maxDist);
+
+    // project second corner
+    corner.copy(center).add(u).add(v).subtract(w);
+
+    toCenter.copy(corner).subtract(position);
+    mag = direction.dot(toCenter);
+
+    minDist = Math.min(mag, minDist);
+    maxDist = Math.max(mag, maxDist);
+
+    // project third corner
+    corner.copy(center).add(u).subtract(v).add(w);
+
+    toCenter.copy(corner).subtract(position);
+    mag = direction.dot(toCenter);
+
+    minDist = Math.min(mag, minDist);
+    maxDist = Math.max(mag, maxDist);
+
+    // project fourth corner
+    corner.copy(center).add(u).subtract(v).subtract(w);
+
+    toCenter.copy(corner).subtract(position);
+    mag = direction.dot(toCenter);
+
+    minDist = Math.min(mag, minDist);
+    maxDist = Math.max(mag, maxDist);
+
+    // project fifth corner
+    center.copy(corner).subtract(u).add(v).add(w);
+
+    toCenter.copy(corner).subtract(position);
+    mag = direction.dot(toCenter);
+
+    minDist = Math.min(mag, minDist);
+    maxDist = Math.max(mag, maxDist);
+
+    // project sixth corner
+    center.copy(corner).subtract(u).add(v).subtract(w);
+
+    toCenter.copy(corner).subtract(position);
+    mag = direction.dot(toCenter);
+
+    minDist = Math.min(mag, minDist);
+    maxDist = Math.max(mag, maxDist);
+
+    // project seventh corner
+    center.copy(corner).subtract(u).subtract(v).add(w);
+
+    toCenter.copy(corner).subtract(position);
+    mag = direction.dot(toCenter);
+
+    minDist = Math.min(mag, minDist);
+    maxDist = Math.max(mag, maxDist);
+
+    // project eighth corner
+    center.copy(corner).subtract(u).subtract(v).subtract(w);
+
+    toCenter.copy(corner).subtract(position);
+    mag = direction.dot(toCenter);
+
+    minDist = Math.min(mag, minDist);
+    maxDist = Math.max(mag, maxDist);
+
+    result[0] = minDist;
+    result[1] = maxDist;
+    return result;
+  }
+
+  /**
+   * Applies a 4x4 affine transformation matrix to a bounding sphere.
+   * @param transform The transformation matrix to apply to the bounding sphere.
+   * @returns itself, i.e. the modified BoundingVolume.
+   */
+  transform(transformation: readonly number[]): this {
+    this.center.transformAsPoint(transformation);
+
+    const xAxis = this.halfAxes.getColumn(0, scratchVectorU);
+    xAxis.transformAsPoint(transformation);
+
+    const yAxis = this.halfAxes.getColumn(1, scratchVectorV);
+    yAxis.transformAsPoint(transformation);
+
+    const zAxis = this.halfAxes.getColumn(2, scratchVectorW);
+    zAxis.transformAsPoint(transformation);
+
+    this.halfAxes = new Matrix3([...xAxis, ...yAxis, ...zAxis]);
+    return this;
+  }
+
+  getTransform(): Matrix4 {
+    // const modelMatrix = Matrix4.fromRotationTranslation(this.boundingVolume.halfAxes, this.boundingVolume.center);
+    // return modelMatrix;
+    throw new Error('not implemented');
+  }
+}