@woosh/meep-engine
Version:
Pure JavaScript game engine. Fully featured and production ready.
468 lines • 11.5 kB
TypeScript
/**
* Axis-Aligned bounding box in 3D
* NOTE: In cases where all you want is raw performance - prefer to use typed arrays instead along with `aabb3_` functions
* @extends {ArrayLike.<number>}
*/
export class AABB3 {
/**
*
* @param {number} [x0]
* @param {number} [y0]
* @param {number} [z0]
* @param {number} [x1]
* @param {number} [y1]
* @param {number} [z1]
* @constructor
*/
constructor(x0?: number, y0?: number, z0?: number, x1?: number, y1?: number, z1?: number);
/**
*
* @param {number} v
*/
set 0(arg: number);
/**
*
* @returns {number}
*/
get 0(): number;
/**
*
* @param {number} v
*/
set 1(arg: number);
/**
*
* @returns {number}
*/
get 1(): number;
/**
*
* @param {number} v
*/
set 2(arg: number);
/**
*
* @returns {number}
*/
get 2(): number;
/**
*
* @param {number} v
*/
set 3(arg: number);
/**
*
* @returns {number}
*/
get 3(): number;
/**
*
* @param {number} v
*/
set 4(arg: number);
/**
*
* @returns {number}
*/
get 4(): number;
/**
*
* @param {number} v
*/
set 5(arg: number);
/**
*
* @returns {number}
*/
get 5(): number;
x0: number;
y0: number;
z0: number;
x1: number;
y1: number;
z1: number;
/**
*
* @param {number} x
* @param {number} y
* @param {number} z
* @param {number} tolerance
* @returns {boolean}
*/
containsPointWithTolerance(x: number, y: number, z: number, tolerance: number): boolean;
/**
*
* @returns {number}
*/
computeSurfaceArea(): number;
/**
*
* @returns {number}
*/
getSurfaceArea(): number;
/**
*
* @returns {number}
*/
computeVolume(): number;
/**
*
* @param {AABB3} other
*/
copy(other: AABB3): void;
/**
*
* @param {Number} x0
* @param {Number} y0
* @param {Number} z0
* @param {Number} x1
* @param {Number} y1
* @param {Number} z1
*/
setBounds(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void;
/**
*
* @param {AABB3} other
* @returns {boolean}
*/
equals(other: AABB3): boolean;
/**
*
* @param {Number} x0
* @param {Number} y0
* @param {Number} z0
* @param {Number} x1
* @param {Number} y1
* @param {Number} z1
* @returns {boolean}
*/
_equals(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): boolean;
/**
* @returns {number}
*/
hash(): number;
/**
* 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: number, y0: number, z0: number, x1: number, y1: number, z1: number): void;
setNegativelyInfiniteBounds(): void;
setInfiniteBounds(): void;
/**
*
* @param {number} x
* @param {number} y
* @param {number} z
*/
_translate(x: number, y: number, z: number): void;
/**
*
* @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
* @deprecated use {@link aabb3_signed_distance_sqr_to_point} directly
*/
distanceToPoint2(x: number, y: number, z: number): number;
/**
*
* @param {AABB3} box
* @returns {number}
*/
distanceToBox(box: AABB3): number;
/**
* 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: number, y0: number, z0: number, x1: number, y1: number, z1: number): number;
/**
*
* @param {AABB3} other
* @returns {number}
* @deprecated
*/
costForInclusion(other: AABB3): number;
/**
* 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}
* @deprecated
*/
_costForInclusion(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): number;
/**
*
* @param {number} x
* @param {number} y
* @param {number} z
* @returns {boolean}
*/
_expandToFitPoint(x: number, y: number, z: number): boolean;
/**
*
* @param {AABB3} other
*/
union(other: AABB3): void;
/**
*
* @param {AABB3} box
* @returns {boolean}
* @deprecated use {@link AABB3#union} instead
*/
expandToFit(box: AABB3): boolean;
/**
*
* @param {number} x0
* @param {number} y0
* @param {number} z0
* @param {number} x1
* @param {number} y1
* @param {number} z1
* @returns {boolean}
*/
_expandToFit(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): boolean;
/**
*
* @param {number} x0
* @param {number} y0
* @param {number} z0
* @param {number} x1
* @param {number} y1
* @param {number} z1
* @returns {boolean}
*/
_containsBox(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): boolean;
/**
*
* @param {AABB3} box
* @returns {boolean}
*/
containsBox(box: AABB3): boolean;
/**
*
* @returns {number}
*/
getExtentsX(): number;
get width(): number;
/**
*
* @returns {number}
*/
getExtentsY(): number;
get height(): number;
/**
*
* @returns {number}
*/
getExtentsZ(): number;
get depth(): number;
/**
* half-width in X axis
* @returns {number}
*/
getHalfExtentsX(): number;
/**
* half-width in Y axis
* @returns {number}
*/
getHalfExtentsY(): number;
/**
* half-width in Z axis
* @returns {number}
*/
getHalfExtentsZ(): number;
/**
*
* @param {Vector3} [target]
* @returns {Vector3}
*/
getExtents(target?: Vector3): Vector3;
/**
*
* @returns {number}
*/
getCenterX(): number;
get centerX(): number;
/**
*
* @returns {number}
*/
getCenterY(): number;
get centerY(): number;
/**
*
* @returns {number}
*/
getCenterZ(): number;
get centerZ(): number;
/**
* Get center position of the box
* @param {Vector3} [target] where to write result
*/
getCenter(target?: Vector3): Vector3;
/**
* 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: any, oY: any, oZ: any, dX: any, dY: any, dZ: any): boolean;
intersectSegment(startX: any, startY: any, startZ: any, endX: any, endY: any, endZ: any): boolean;
/**
* @deprecated use {@link AABB3#_containsBox} instead
* @param {THREE.Box} box
* @returns {boolean}
*/
threeContainsBox(box: THREE.Box): boolean;
/**
*
* @param {function(x:number, y:number, z:number)} callback
* @param {*} [thisArg]
*/
traverseCorners(callback: any, thisArg?: any): void;
/**
*
* @param {number[]|Float64Array|Float32Array} result
*/
getCorners(result: number[] | Float64Array | Float32Array): void;
/**
*
* @param {number[]|Float32Array|Float64Array} result
* @param {number} offset
*/
writeToArray(result?: number[] | Float32Array | Float64Array, offset?: number): number[] | Float32Array | Float64Array;
/**
*
* @param {number[]|Float32Array|Float64Array} source
* @param {number} offset
*/
readFromArray(source: number[] | Float32Array | Float64Array, offset?: number): void;
/**
* @param {THREE.Plane} plane
* @returns {int} 2,0,or -2; 2: above, -2 : below, 0 : intersects plane
*/
computePlaneSide(plane: THREE.Plane): int;
/**
*
* @param {number} normal_x
* @param {number} normal_y
* @param {number} normal_z
* @param {number} offset
* @returns {number}
*/
computeDistanceAbovePlane(normal_x: number, normal_y: number, normal_z: number, offset: number): number;
/**
*
* @param {number} normal_x
* @param {number} normal_y
* @param {number} normal_z
* @param {number} offset
* @returns {boolean}
*/
_isBelowPlane(normal_x: number, normal_y: number, normal_z: number, offset: number): boolean;
/**
*
* @param {Plane} plane
* @return {boolean}
*/
isBelowPlane(plane: Plane): boolean;
/**
* @param {Plane[]} clippingPlanes
* @returns {boolean}
*/
intersectSpace(clippingPlanes: Plane[]): boolean;
/**
*
* @param {Frustum} frustum
* @returns {number}
*/
intersectFrustumDegree(frustum: Frustum): number;
/**
*
* @param {number[]} frustum
* @returns {number}
*/
intersectFrustumDegree_array(frustum: number[]): number;
/**
*
* @param {{planes:Array}}frustum
* @returns {boolean}
*/
intersectFrustum(frustum: {
planes: any[];
}): boolean;
/**
*
* @param {ArrayLike<number>|number[]|Float32Array}frustum
* @returns {boolean}
*/
intersectFrustum_array(frustum: ArrayLike<number> | number[] | Float32Array): boolean;
/**
*
* @param {number[]|ArrayLike<number>|Float32Array} matrix
*/
applyMatrix4(matrix: number[] | ArrayLike<number> | Float32Array): void;
/**
* Expands the box in all directions by the given amount
* @param {number} extra
*/
grow(extra: number): void;
/**
*
* @returns {AABB3}
*/
clone(): AABB3;
fromJSON({ x0, y0, z0, x1, y1, z1 }: {
x0: any;
y0: any;
z0: any;
x1: any;
y1: any;
z1: any;
}): void;
toJSON(): {
x0: number;
y0: number;
z0: number;
x1: number;
y1: number;
z1: number;
};
toString(): string;
/**
* @readonly
* @type {boolean}
*/
readonly isAABB3: boolean;
toArray: (result?: number[] | Float32Array | Float64Array, offset?: number) => number[] | Float32Array | Float64Array;
fromArray: (source: number[] | Float32Array | Float64Array, offset?: number) => void;
/**
* Pretending to be an array
* @readonly
* @type {number}
*/
readonly length: number;
[Symbol.iterator](): Generator<number, void, unknown>;
}
import Vector3 from "../../Vector3.js";
//# sourceMappingURL=AABB3.d.ts.map