org.joml.AABBd Maven / Gradle / Ivy
/*
* The MIT License
*
* Copyright (c) 2017-2020 JOML
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.joml;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.text.DecimalFormat;
import java.text.NumberFormat;
/**
* Represents an axis-aligned box defined via the minimum and maximum corner coordinates.
*
* @author Kai Burjack
*/
public class AABBd implements Externalizable {
/**
* The x coordinate of the minimum corner.
*/
public double minX = Double.POSITIVE_INFINITY;
/**
* The y coordinate of the minimum corner.
*/
public double minY = Double.POSITIVE_INFINITY;
/**
* The z coordinate of the minimum corner.
*/
public double minZ = Double.POSITIVE_INFINITY;
/**
* The x coordinate of the maximum corner.
*/
public double maxX = Double.NEGATIVE_INFINITY;
/**
* The y coordinate of the maximum corner.
*/
public double maxY = Double.NEGATIVE_INFINITY;
/**
* The z coordinate of the maximum corner.
*/
public double maxZ = Double.NEGATIVE_INFINITY;
/**
* Create a new {@link AABBd} representing the box with
* (minX, minY, minZ)=(+inf, +inf, +inf) and (maxX, maxY, maxZ)=(-inf, -inf, -inf).
*/
public AABBd() {
}
/**
* Create a new {@link AABBd} as a copy of the given source.
*
* @param source
* the {@link AABBd} to copy from
*/
public AABBd(AABBd source) {
this.minX = source.minX;
this.minY = source.minY;
this.minZ = source.minZ;
this.maxX = source.maxX;
this.maxY = source.maxY;
this.maxZ = source.maxZ;
}
/**
* Create a new {@link AABBd} with the given minimum and maximum corner coordinates.
*
* @param min
* the minimum coordinates
* @param max
* the maximum coordinates
*/
public AABBd(Vector3fc min, Vector3fc max) {
this.minX = min.x();
this.minY = min.y();
this.minZ = min.z();
this.maxX = max.x();
this.maxY = max.y();
this.maxZ = max.z();
}
/**
* Create a new {@link AABBd} with the given minimum and maximum corner coordinates.
*
* @param min
* the minimum coordinates
* @param max
* the maximum coordinates
*/
public AABBd(Vector3dc min, Vector3dc max) {
this.minX = min.x();
this.minY = min.y();
this.minZ = min.z();
this.maxX = max.x();
this.maxY = max.y();
this.maxZ = max.z();
}
/**
* Create a new {@link AABBd} with the given minimum and maximum corner coordinates.
*
* @param minX
* the x coordinate of the minimum corner
* @param minY
* the y coordinate of the minimum corner
* @param minZ
* the z coordinate of the minimum corner
* @param maxX
* the x coordinate of the maximum corner
* @param maxY
* the y coordinate of the maximum corner
* @param maxZ
* the z coordinate of the maximum corner
*/
public AABBd(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) {
this.minX = minX;
this.minY = minY;
this.minZ = minZ;
this.maxX = maxX;
this.maxY = maxY;
this.maxZ = maxZ;
}
/**
* Set this {@link AABBd} to be a clone of source.
*
* @param source
* the {@link AABBd} to copy from
* @return this
*/
public AABBd set(AABBd source){
this.minX = source.minX;
this.minY = source.minY;
this.minZ = source.minZ;
this.maxX = source.maxX;
this.maxY = source.maxY;
this.maxZ = source.maxZ;
return this;
}
private AABBd validate() {
if (!isValid()) {
minX = Double.POSITIVE_INFINITY;
minY = Double.POSITIVE_INFINITY;
minZ = Double.POSITIVE_INFINITY;
maxX = Double.NEGATIVE_INFINITY;
maxY = Double.NEGATIVE_INFINITY;
maxZ = Double.NEGATIVE_INFINITY;
}
return this;
}
/**
* Check whether this AABB represents a valid AABB.
*
* @return true iff this AABB is valid; false otherwise
*/
public boolean isValid() {
return minX < maxX && minY < maxY && minZ < maxZ;
}
/**
* Set the minimum corner coordinates.
*
* @param minX
* the x coordinate of the minimum corner
* @param minY
* the y coordinate of the minimum corner
* @param minZ
* the z coordinate of the minimum corner
* @return this
*/
public AABBd setMin(double minX, double minY, double minZ) {
this.minX = minX;
this.minY = minY;
this.minZ = minZ;
return this;
}
/**
* Set the maximum corner coordinates.
*
* @param maxX
* the x coordinate of the maximum corner
* @param maxY
* the y coordinate of the maximum corner
* @param maxZ
* the z coordinate of the maximum corner
* @return this
*/
public AABBd setMax(double maxX, double maxY, double maxZ) {
this.maxX = maxX;
this.maxY = maxY;
this.maxZ = maxZ;
return this;
}
/**
* Set the minimum corner coordinates.
*
* @param min
* the minimum coordinates
* @return this
*/
public AABBd setMin(Vector3dc min) {
return this.setMin(min.x(), min.y(), min.z());
}
/**
* Set the maximum corner coordinates.
*
* @param max
* the maximum coordinates
* @return this
*/
public AABBd setMax(Vector3dc max) {
return this.setMax(max.x(), max.y(), max.z());
}
/**
* Get the maximum corner coordinate of the given component.
*
* @param component
* the component, within [0..2]
* @return the maximum coordinate
* @throws IllegalArgumentException if component is not within [0..2]
*/
public double getMax(int component) throws IllegalArgumentException {
switch (component) {
case 0:
return maxX;
case 1:
return maxY;
case 2:
return maxZ;
default:
throw new IllegalArgumentException();
}
}
/**
* Get the minimum corner coordinate of the given component.
*
* @param component
* the component, within [0..2]
* @return the maximum coordinate
* @throws IllegalArgumentException if component is not within [0..2]
*/
public double getMin(int component) throws IllegalArgumentException {
switch (component) {
case 0:
return minX;
case 1:
return minY;
case 2:
return minZ;
default:
throw new IllegalArgumentException();
}
}
/**
* Set this to the union of this and the given point (x, y, z).
*
* @param x
* the x coordinate of the point
* @param y
* the y coordinate of the point
* @param z
* the z coordinate of the point
* @return this
*/
public AABBd union(double x, double y, double z) {
return union(x, y, z, this);
}
/**
* Set this to the union of this and the given point p.
*
* @param p
* the point
* @return this
*/
public AABBd union(Vector3dc p) {
return union(p.x(), p.y(), p.z(), this);
}
/**
* Compute the union of this and the given point (x, y, z) and store the result in dest.
*
* @param x
* the x coordinate of the point
* @param y
* the y coordinate of the point
* @param z
* the z coordinate of the point
* @param dest
* will hold the result
* @return dest
*/
public AABBd union(double x, double y, double z, AABBd dest) {
dest.minX = this.minX < x ? this.minX : x;
dest.minY = this.minY < y ? this.minY : y;
dest.minZ = this.minZ < z ? this.minZ : z;
dest.maxX = this.maxX > x ? this.maxX : x;
dest.maxY = this.maxY > y ? this.maxY : y;
dest.maxZ = this.maxZ > z ? this.maxZ : z;
return dest;
}
/**
* Compute the union of this and the given point p and store the result in dest.
*
* @param p
* the point
* @param dest
* will hold the result
* @return dest
*/
public AABBd union(Vector3dc p, AABBd dest) {
return union(p.x(), p.y(), p.z(), dest);
}
/**
* Set this to the union of this and other.
*
* @param other
* the other {@link AABBd}
* @return this
*/
public AABBd union(AABBd other) {
return this.union(other, this);
}
/**
* Compute the union of this and other and store the result in dest.
*
* @param other
* the other {@link AABBd}
* @param dest
* will hold the result
* @return dest
*/
public AABBd union(AABBd other, AABBd dest) {
dest.minX = this.minX < other.minX ? this.minX : other.minX;
dest.minY = this.minY < other.minY ? this.minY : other.minY;
dest.minZ = this.minZ < other.minZ ? this.minZ : other.minZ;
dest.maxX = this.maxX > other.maxX ? this.maxX : other.maxX;
dest.maxY = this.maxY > other.maxY ? this.maxY : other.maxY;
dest.maxZ = this.maxZ > other.maxZ ? this.maxZ : other.maxZ;
return dest;
}
/**
* Ensure that the minimum coordinates are strictly less than or equal to the maximum coordinates by swapping
* them if necessary.
*
* @return this
*/
public AABBd correctBounds() {
double tmp;
if (this.minX > this.maxX) {
tmp = this.minX;
this.minX = this.maxX;
this.maxX = tmp;
}
if (this.minY > this.maxY) {
tmp = this.minY;
this.minY = this.maxY;
this.maxY = tmp;
}
if (this.minZ > this.maxZ) {
tmp = this.minZ;
this.minZ = this.maxZ;
this.maxZ = tmp;
}
return this;
}
/**
* Translate this by the given vector xyz.
*
* @param xyz
* the vector to translate by
* @return this
*/
public AABBd translate(Vector3dc xyz) {
return translate(xyz.x(), xyz.y(), xyz.z(), this);
}
/**
* Translate this by the given vector xyz and store the result in dest.
*
* @param xyz
* the vector to translate by
* @param dest
* will hold the result
* @return dest
*/
public AABBd translate(Vector3dc xyz, AABBd dest) {
return translate(xyz.x(), xyz.y(), xyz.z(), dest);
}
/**
* Translate this by the given vector xyz.
*
* @param xyz
* the vector to translate by
* @return this
*/
public AABBd translate(Vector3fc xyz) {
return translate(xyz.x(), xyz.y(), xyz.z(), this);
}
/**
* Translate this by the given vector xyz and store the result in dest.
*
* @param xyz
* the vector to translate by
* @param dest
* will hold the result
* @return dest
*/
public AABBd translate(Vector3fc xyz, AABBd dest) {
return translate(xyz.x(), xyz.y(), xyz.z(), dest);
}
/**
* Translate this by the vector (x, y, z).
*
* @param x
* the x coordinate to translate by
* @param y
* the y coordinate to translate by
* @param z
* the z coordinate to translate by
* @return this
*/
public AABBd translate(double x, double y, double z) {
return translate(x, y, z, this);
}
/**
* Translate this by the vector (x, y, z) and store the result in dest.
*
* @param x
* the x coordinate to translate by
* @param y
* the y coordinate to translate by
* @param z
* the z coordinate to translate by
* @param dest
* will hold the result
* @return dest
*/
public AABBd translate(double x, double y, double z, AABBd dest) {
dest.minX = minX + x;
dest.minY = minY + y;
dest.minZ = minZ + z;
dest.maxX = maxX + x;
dest.maxY = maxY + y;
dest.maxZ = maxZ + z;
return dest;
}
/**
* Compute the AABB of intersection between this and the given AABB.
*
* If the two AABBs do not intersect, then the minimum coordinates of this
* will have a value of {@link Double#POSITIVE_INFINITY} and the maximum coordinates will have a value of
* {@link Double#NEGATIVE_INFINITY}.
*
* @param other
* the other AABB
* @param dest
* will hold the result
* @return dest
*/
public AABBd intersection(AABBd other, AABBd dest) {
dest.minX = Math.max(minX, other.minX);
dest.minY = Math.max(minY, other.minY);
dest.minZ = Math.max(minZ, other.minZ);
dest.maxX = Math.min(maxX, other.maxX);
dest.maxY = Math.min(maxY, other.maxY);
dest.maxZ = Math.min(maxZ, other.maxZ);
return dest.validate();
}
/**
* Compute the AABB of intersection between this and the given AABB.
*
* If the two AABBs do not intersect, then the minimum coordinates of this
* will have a value of {@link Double#POSITIVE_INFINITY} and the maximum coordinates will have a value of
* {@link Double#NEGATIVE_INFINITY}.
*
* @param other
* the other AABB
* @return this
*/
public AABBd intersection(AABBd other) {
return intersection(other, this);
}
/**
* Check if this AABB contains the given AABB.
*
* @param aabb
* the AABB to test
* @return true iff this AABB contains the AABB; false otherwise
*/
public boolean containsAABB(AABBd aabb) {
return aabb.minX >= minX && aabb.maxX <= maxX &&
aabb.minY >= minY && aabb.maxY <= maxY &&
aabb.minZ >= minZ && aabb.maxZ <= maxZ;
}
/**
* Check if this AABB contains the given AABB.
*
* @param aabb
* the AABB to test
* @return true iff this AABB contains the AABB; false otherwise
*/
public boolean containsAABB(AABBf aabb) {
return aabb.minX >= minX && aabb.maxX <= maxX &&
aabb.minY >= minY && aabb.maxY <= maxY &&
aabb.minZ >= minZ && aabb.maxZ <= maxZ;
}
/**
* Check if this AABB contains the given AABB.
*
* @param aabb
* the AABB to test
* @return true iff this AABB contains the AABB; false otherwise
*/
public boolean containsAABB(AABBi aabb) {
return aabb.minX >= minX && aabb.maxX <= maxX &&
aabb.minY >= minY && aabb.maxY <= maxY &&
aabb.minZ >= minZ && aabb.maxZ <= maxZ;
}
/**
* Test whether the point (x, y, z) lies inside this AABB.
*
* @param x
* the x coordinate of the point
* @param y
* the y coordinate of the point
* @param z
* the z coordinate of the point
* @return true iff the given point lies inside this AABB; false otherwise
*/
public boolean containsPoint(double x, double y, double z) {
return x >= minX && y >= minY && z >= minZ && x <= maxX && y <= maxY && z <= maxZ;
}
/**
* Test whether the given point lies inside this AABB.
*
* @param point
* the coordinates of the point
* @return true iff the given point lies inside this AABB; false otherwise
*/
public boolean containsPoint(Vector3dc point) {
return containsPoint(point.x(), point.y(), point.z());
}
/**
* Test whether the plane given via its plane equation a*x + b*y + c*z + d = 0 intersects this AABB.
*
* Reference: http://www.lighthouse3d.com ("Geometric Approach - Testing Boxes II")
*
* @param a
* the x factor in the plane equation
* @param b
* the y factor in the plane equation
* @param c
* the z factor in the plane equation
* @param d
* the constant in the plane equation
* @return true iff the plane intersects this AABB; false otherwise
*/
public boolean intersectsPlane(double a, double b, double c, double d) {
return Intersectiond.testAabPlane(minX, minY, minZ, maxX, maxY, maxZ, a, b, c, d);
}
/**
* Test whether the given plane intersects this AABB.
*
* Reference: http://www.lighthouse3d.com ("Geometric Approach - Testing Boxes II")
*
* @param plane
* the plane
* @return true iff the plane intersects this AABB; false otherwise
*/
public boolean intersectsPlane(Planed plane) {
return Intersectiond.testAabPlane(this, plane);
}
/**
* Test whether this and other intersect.
*
* @param other
* the other AABB
* @return true iff both AABBs intersect; false otherwise
*/
public boolean intersectsAABB(AABBd other) {
return this.maxX >= other.minX && this.maxY >= other.minY && this.maxZ >= other.minZ &&
this.minX <= other.maxX && this.minY <= other.maxY && this.minZ <= other.maxZ;
}
/**
* Test whether this AABB intersects the given sphere with equation
* (x - centerX)^2 + (y - centerY)^2 + (z - centerZ)^2 - radiusSquared = 0.
*
* Reference: http://stackoverflow.com
*
* @param centerX
* the x coordinate of the center of the sphere
* @param centerY
* the y coordinate of the center of the sphere
* @param centerZ
* the z coordinate of the center of the sphere
* @param radiusSquared
* the square radius of the sphere
* @return true iff this AABB and the sphere intersect; false otherwise
*/
public boolean intersectsSphere(double centerX, double centerY, double centerZ, double radiusSquared) {
return Intersectiond.testAabSphere(minX, minY, minZ, maxX, maxY, maxZ, centerX, centerY, centerZ, radiusSquared);
}
/**
* Test whether this AABB intersects the given sphere.
*
* Reference: http://stackoverflow.com
*
* @param sphere
* the sphere
* @return true iff this AABB and the sphere intersect; false otherwise
*/
public boolean intersectsSphere(Spheref sphere) {
return Intersectiond.testAabSphere(this, sphere);
}
/**
* Test whether the given ray with the origin (originX, originY, originZ) and direction (dirX, dirY, dirZ)
* intersects this AABB.
*
* This method returns true for a ray whose origin lies inside this AABB.
*
* Reference: An Efficient and Robust Ray–Box Intersection
*
* @param originX
* the x coordinate of the ray's origin
* @param originY
* the y coordinate of the ray's origin
* @param originZ
* the z coordinate of the ray's origin
* @param dirX
* the x coordinate of the ray's direction
* @param dirY
* the y coordinate of the ray's direction
* @param dirZ
* the z coordinate of the ray's direction
* @return true if this AABB and the ray intersect; false otherwise
*/
public boolean intersectsRay(double originX, double originY, double originZ, double dirX, double dirY, double dirZ) {
return Intersectiond.testRayAab(originX, originY, originZ, dirX, dirY, dirZ, minX, minY, minZ, maxX, maxY, maxZ);
}
/**
* Test whether the given ray intersects this AABB.
*
* This method returns true for a ray whose origin lies inside this AABB.
*
* Reference: An Efficient and Robust Ray–Box Intersection
*
* @param ray
* the ray
* @return true if this AABB and the ray intersect; false otherwise
*/
public boolean intersectsRay(Rayd ray) {
return Intersectiond.testRayAab(ray, this);
}
/**
* Determine whether the given ray with the origin (originX, originY, originZ) and direction (dirX, dirY, dirZ)
* intersects this AABB, and return the values of the parameter t in the ray equation
* p(t) = origin + t * dir of the near and far point of intersection.
*
* This method returns true for a ray whose origin lies inside this AABB.
*
* Reference: An Efficient and Robust Ray–Box Intersection
*
* @param originX
* the x coordinate of the ray's origin
* @param originY
* the y coordinate of the ray's origin
* @param originZ
* the z coordinate of the ray's origin
* @param dirX
* the x coordinate of the ray's direction
* @param dirY
* the y coordinate of the ray's direction
* @param dirZ
* the z coordinate of the ray's direction
* @param result
* a vector which will hold the resulting values of the parameter
* t in the ray equation p(t) = origin + t * dir of the near and far point of intersection
* iff the ray intersects this AABB
* @return true if the given ray intersects this AABB; false otherwise
*/
public boolean intersectsRay(double originX, double originY, double originZ, double dirX, double dirY, double dirZ, Vector2d result) {
return Intersectiond.intersectRayAab(originX, originY, originZ, dirX, dirY, dirZ, minX, minY, minZ, maxX, maxY, maxZ, result);
}
/**
* Determine whether the given ray intersects this AABB, and return the values of the parameter t in the ray equation
* p(t) = origin + t * dir of the near and far point of intersection.
*
* This method returns true for a ray whose origin lies inside this AABB.
*
* Reference: An Efficient and Robust Ray–Box Intersection
*
* @param ray
* the ray
* @param result
* a vector which will hold the resulting values of the parameter
* t in the ray equation p(t) = origin + t * dir of the near and far point of intersection
* iff the ray intersects this AABB
* @return true if the given ray intersects this AABB; false otherwise
*/
public boolean intersectsRay(Rayd ray, Vector2d result) {
return Intersectiond.intersectRayAab(ray, this, result);
}
/**
* Determine whether the undirected line segment with the end points (p0X, p0Y, p0Z) and (p1X, p1Y, p1Z)
* intersects this AABB, and return the values of the parameter t in the ray equation
* p(t) = origin + p0 * (p1 - p0) of the near and far point of intersection.
*
* This method returns true for a line segment whose either end point lies inside this AABB.
*
* Reference: An Efficient and Robust Ray–Box Intersection
*
* @param p0X
* the x coordinate of the line segment's first end point
* @param p0Y
* the y coordinate of the line segment's first end point
* @param p0Z
* the z coordinate of the line segment's first end point
* @param p1X
* the x coordinate of the line segment's second end point
* @param p1Y
* the y coordinate of the line segment's second end point
* @param p1Z
* the z coordinate of the line segment's second end point
* @param result
* a vector which will hold the resulting values of the parameter
* t in the ray equation p(t) = p0 + t * (p1 - p0) of the near and far point of intersection
* iff the line segment intersects this AABB
* @return {@link Intersectiond#INSIDE} if the line segment lies completely inside of this AABB; or
* {@link Intersectiond#OUTSIDE} if the line segment lies completely outside of this AABB; or
* {@link Intersectiond#ONE_INTERSECTION} if one of the end points of the line segment lies inside of this AABB; or
* {@link Intersectiond#TWO_INTERSECTION} if the line segment intersects two sides of this AABB or lies on an edge or a side of this AABB
*/
public int intersectsLineSegment(double p0X, double p0Y, double p0Z, double p1X, double p1Y, double p1Z, Vector2d result) {
return Intersectiond.intersectLineSegmentAab(p0X, p0Y, p0Z, p1X, p1Y, p1Z, minX, minY, minZ, maxX, maxY, maxZ, result);
}
/**
* Determine whether the given undirected line segment intersects this AABB, and return the values of the parameter t in the ray equation
* p(t) = origin + p0 * (p1 - p0) of the near and far point of intersection.
*
* This method returns true for a line segment whose either end point lies inside this AABB.
*
* Reference: An Efficient and Robust Ray–Box Intersection
*
* @param lineSegment
* the line segment
* @param result
* a vector which will hold the resulting values of the parameter
* t in the ray equation p(t) = p0 + t * (p1 - p0) of the near and far point of intersection
* iff the line segment intersects this AABB
* @return {@link Intersectiond#INSIDE} if the line segment lies completely inside of this AABB; or
* {@link Intersectiond#OUTSIDE} if the line segment lies completely outside of this AABB; or
* {@link Intersectiond#ONE_INTERSECTION} if one of the end points of the line segment lies inside of this AABB; or
* {@link Intersectiond#TWO_INTERSECTION} if the line segment intersects two sides of this AABB or lies on an edge or a side of this AABB
*/
public int intersectsLineSegment(LineSegmentf lineSegment, Vector2d result) {
return Intersectiond.intersectLineSegmentAab(lineSegment, this, result);
}
/**
* Apply the given {@link Matrix4dc#isAffine() affine} transformation to this {@link AABBd}.
*
* The matrix in m must be {@link Matrix4dc#isAffine() affine}.
*
* @param m
* the affine transformation matrix
* @return this
*/
public AABBd transform(Matrix4dc m) {
return transform(m, this);
}
/**
* Apply the given {@link Matrix4dc#isAffine() affine} transformation to this {@link AABBd}
* and store the resulting AABB into dest.
*
* The matrix in m must be {@link Matrix4dc#isAffine() affine}.
*
* @param m
* the affine transformation matrix
* @param dest
* will hold the result
* @return dest
*/
public AABBd transform(Matrix4dc m, AABBd dest) {
double dx = maxX - minX, dy = maxY - minY, dz = maxZ - minZ;
double minx = Double.POSITIVE_INFINITY, miny = Double.POSITIVE_INFINITY, minz = Double.POSITIVE_INFINITY;
double maxx = Double.NEGATIVE_INFINITY, maxy = Double.NEGATIVE_INFINITY, maxz = Double.NEGATIVE_INFINITY;
for (int i = 0; i < 8; i++) {
double x = minX + (i & 1) * dx, y = minY + (i >> 1 & 1) * dy, z = minZ + (i >> 2 & 1) * dz;
double tx = m.m00() * x + m.m10() * y + m.m20() * z + m.m30();
double ty = m.m01() * x + m.m11() * y + m.m21() * z + m.m31();
double tz = m.m02() * x + m.m12() * y + m.m22() * z + m.m32();
minx = Math.min(tx, minx);
miny = Math.min(ty, miny);
minz = Math.min(tz, minz);
maxx = Math.max(tx, maxx);
maxy = Math.max(ty, maxy);
maxz = Math.max(tz, maxz);
}
dest.minX = minx;
dest.minY = miny;
dest.minZ = minz;
dest.maxX = maxx;
dest.maxY = maxy;
dest.maxZ = maxz;
return dest;
}
public int hashCode() {
final int prime = 31;
int result = 1;
long temp;
temp = Double.doubleToLongBits(maxX);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(maxY);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(maxZ);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(minX);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(minY);
result = prime * result + (int) (temp ^ (temp >>> 32));
temp = Double.doubleToLongBits(minZ);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
AABBd other = (AABBd) obj;
if (Double.doubleToLongBits(maxX) != Double.doubleToLongBits(other.maxX))
return false;
if (Double.doubleToLongBits(maxY) != Double.doubleToLongBits(other.maxY))
return false;
if (Double.doubleToLongBits(maxZ) != Double.doubleToLongBits(other.maxZ))
return false;
if (Double.doubleToLongBits(minX) != Double.doubleToLongBits(other.minX))
return false;
if (Double.doubleToLongBits(minY) != Double.doubleToLongBits(other.minY))
return false;
if (Double.doubleToLongBits(minZ) != Double.doubleToLongBits(other.minZ))
return false;
return true;
}
/**
* Return a string representation of this AABB.
*
* This method creates a new {@link DecimalFormat} on every invocation with the format string "0.000E0;-".
*
* @return the string representation
*/
public String toString() {
return Runtime.formatNumbers(toString(Options.NUMBER_FORMAT));
}
/**
* Return a string representation of this AABB by formatting the vector components with the given {@link NumberFormat}.
*
* @param formatter
* the {@link NumberFormat} used to format the vector components with
* @return the string representation
*/
public String toString(NumberFormat formatter) {
return "(" + Runtime.format(minX, formatter) + " " + Runtime.format(minY, formatter) + " " + Runtime.format(minZ, formatter) + ") < "
+ "(" + Runtime.format(maxX, formatter) + " " + Runtime.format(maxY, formatter) + " " + Runtime.format(maxZ, formatter) + ")";
}
public void writeExternal(ObjectOutput out) throws IOException {
out.writeDouble(minX);
out.writeDouble(minY);
out.writeDouble(minZ);
out.writeDouble(maxX);
out.writeDouble(maxY);
out.writeDouble(maxZ);
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
minX = in.readDouble();
minY = in.readDouble();
minZ = in.readDouble();
maxX = in.readDouble();
maxY = in.readDouble();
maxZ = in.readDouble();
}
}