mirror of https://github.com/Minestom/Minestom.git
532 lines
14 KiB
Java
532 lines
14 KiB
Java
package net.minestom.server.utils;
|
|
|
|
import net.minestom.server.MinecraftServer;
|
|
import net.minestom.server.utils.clone.PublicCloneable;
|
|
import org.jetbrains.annotations.NotNull;
|
|
|
|
public class Vector implements PublicCloneable<Vector> {
|
|
|
|
private static final double epsilon = 0.000001;
|
|
|
|
protected double x, y, z;
|
|
|
|
public Vector() {
|
|
this.x = 0;
|
|
this.y = 0;
|
|
this.z = 0;
|
|
}
|
|
|
|
public Vector(double x, double y, double z) {
|
|
this.x = x;
|
|
this.y = y;
|
|
this.z = z;
|
|
}
|
|
|
|
@NotNull
|
|
public Vector add(@NotNull Vector vec) {
|
|
x += vec.x;
|
|
y += vec.y;
|
|
z += vec.z;
|
|
return this;
|
|
}
|
|
|
|
@NotNull
|
|
public Vector add(double x, double y, double z) {
|
|
this.x += x;
|
|
this.y += y;
|
|
this.z += z;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Subtracts a vector from this one.
|
|
*
|
|
* @param vec The other vector
|
|
* @return the same vector
|
|
*/
|
|
@NotNull
|
|
public Vector subtract(@NotNull Vector vec) {
|
|
x -= vec.x;
|
|
y -= vec.y;
|
|
z -= vec.z;
|
|
return this;
|
|
}
|
|
|
|
@NotNull
|
|
public Vector subtract(double x, double y, double z) {
|
|
this.x -= x;
|
|
this.y -= y;
|
|
this.z -= z;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Multiplies the vector by another.
|
|
*
|
|
* @param vec The other vector
|
|
* @return the same vector
|
|
*/
|
|
@NotNull
|
|
public Vector multiply(@NotNull Vector vec) {
|
|
x *= vec.x;
|
|
y *= vec.y;
|
|
z *= vec.z;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Divides the vector by another.
|
|
*
|
|
* @param vec The other vector
|
|
* @return the same vector
|
|
*/
|
|
@NotNull
|
|
public Vector divide(@NotNull Vector vec) {
|
|
x /= vec.x;
|
|
y /= vec.y;
|
|
z /= vec.z;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Copies another vector
|
|
*
|
|
* @param vec The other vector
|
|
* @return the same vector
|
|
*/
|
|
@NotNull
|
|
public Vector copy(@NotNull Vector vec) {
|
|
x = vec.x;
|
|
y = vec.y;
|
|
z = vec.z;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the x/y/z fields of this vector to the value of {@code vector}.
|
|
*
|
|
* @param vector the vector to copy the values from
|
|
*/
|
|
public void copyCoordinates(@NotNull Vector vector) {
|
|
this.x = vector.getX();
|
|
this.y = vector.getY();
|
|
this.z = vector.getZ();
|
|
}
|
|
|
|
/**
|
|
* Gets the magnitude of the vector, defined as sqrt(x^2+y^2+z^2). The
|
|
* value of this method is not cached and uses a costly square-root
|
|
* function, so do not repeatedly call this method to get the vector's
|
|
* magnitude. NaN will be returned if the inner result of the sqrt()
|
|
* function overflows, which will be caused if the length is too long.
|
|
*
|
|
* @return the magnitude
|
|
*/
|
|
public double length() {
|
|
return Math.sqrt(MathUtils.square(x) + MathUtils.square(y) + MathUtils.square(z));
|
|
}
|
|
|
|
/**
|
|
* Gets the magnitude of the vector squared.
|
|
*
|
|
* @return the magnitude
|
|
*/
|
|
public double lengthSquared() {
|
|
return MathUtils.square(x) + MathUtils.square(y) + MathUtils.square(z);
|
|
}
|
|
|
|
/**
|
|
* Gets the distance between this vector and another. The value of this
|
|
* method is not cached and uses a costly square-root function, so do not
|
|
* repeatedly call this method to get the vector's magnitude. NaN will be
|
|
* returned if the inner result of the sqrt() function overflows, which
|
|
* will be caused if the distance is too long.
|
|
*
|
|
* @param o The other vector
|
|
* @return the distance
|
|
*/
|
|
public double distance(@NotNull Vector o) {
|
|
return Math.sqrt(MathUtils.square(x - o.x) + MathUtils.square(y - o.y) + MathUtils.square(z - o.z));
|
|
}
|
|
|
|
/**
|
|
* Gets the squared distance between this vector and another.
|
|
*
|
|
* @param o The other vector
|
|
* @return the squared distance
|
|
*/
|
|
public double distanceSquared(@NotNull Vector o) {
|
|
return MathUtils.square(x - o.x) + MathUtils.square(y - o.y) + MathUtils.square(z - o.z);
|
|
}
|
|
|
|
/**
|
|
* Gets the angle between this vector and another in radians.
|
|
*
|
|
* @param other The other vector
|
|
* @return angle in radians
|
|
*/
|
|
public float angle(@NotNull Vector other) {
|
|
double dot = MathUtils.clamp(dot(other) / (length() * other.length()), -1.0, 1.0);
|
|
|
|
return (float) Math.acos(dot);
|
|
}
|
|
|
|
/**
|
|
* Performs scalar multiplication, multiplying all components with a
|
|
* scalar.
|
|
*
|
|
* @param m The factor
|
|
* @return the same vector
|
|
*/
|
|
@NotNull
|
|
public Vector multiply(int m) {
|
|
x *= m;
|
|
y *= m;
|
|
z *= m;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Performs scalar multiplication, multiplying all components with a
|
|
* scalar.
|
|
*
|
|
* @param m The factor
|
|
* @return the same vector
|
|
*/
|
|
@NotNull
|
|
public Vector multiply(double m) {
|
|
x *= m;
|
|
y *= m;
|
|
z *= m;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Performs scalar multiplication, multiplying all components with a
|
|
* scalar.
|
|
*
|
|
* @param m The factor
|
|
* @return the same vector
|
|
*/
|
|
@NotNull
|
|
public Vector multiply(float m) {
|
|
x *= m;
|
|
y *= m;
|
|
z *= m;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Calculates the dot product of this vector with another. The dot product
|
|
* is defined as x1*x2+y1*y2+z1*z2. The returned value is a scalar.
|
|
*
|
|
* @param other The other vector
|
|
* @return dot product
|
|
*/
|
|
public double dot(@NotNull Vector other) {
|
|
return x * other.x + y * other.y + z * other.z;
|
|
}
|
|
|
|
/**
|
|
* Calculates the cross product of this vector with another. The cross
|
|
* product is defined as:
|
|
* <ul>
|
|
* <li>x = y1 * z2 - y2 * z1
|
|
* <li>y = z1 * x2 - z2 * x1
|
|
* <li>z = x1 * y2 - x2 * y1
|
|
* </ul>
|
|
*
|
|
* @param o The other vector
|
|
* @return the same vector
|
|
*/
|
|
@NotNull
|
|
public Vector crossProduct(@NotNull Vector o) {
|
|
this.x = y * o.z - o.y * z;
|
|
this.y = z * o.x - o.z * x;
|
|
this.z = x * o.y - o.x * y;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Calculates the cross product of this vector with another without mutating
|
|
* the original. The cross product is defined as:
|
|
* <ul>
|
|
* <li>x = y1 * z2 - y2 * z1
|
|
* <li>y = z1 * x2 - z2 * x1
|
|
* <li>z = x1 * y2 - x2 * y1
|
|
* </ul>
|
|
*
|
|
* @param o The other vector
|
|
* @return a new vector
|
|
*/
|
|
@NotNull
|
|
public Vector getCrossProduct(@NotNull Vector o) {
|
|
final double x = this.y * o.z - o.y * this.z;
|
|
final double y = this.z * o.x - o.z * this.x;
|
|
final double z = this.x * o.y - o.x * this.y;
|
|
return new Vector(x, y, z);
|
|
}
|
|
|
|
/**
|
|
* Converts this vector to a unit vector (a vector with length of 1).
|
|
*
|
|
* @return the same vector
|
|
*/
|
|
public Vector normalize() {
|
|
double length = length();
|
|
|
|
x /= length;
|
|
y /= length;
|
|
z /= length;
|
|
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Zero this vector's components.
|
|
*
|
|
* @return the same vector
|
|
*/
|
|
@NotNull
|
|
public Vector zero() {
|
|
x = 0;
|
|
y = 0;
|
|
z = 0;
|
|
return this;
|
|
}
|
|
|
|
public boolean isZero() {
|
|
return getX() == 0 &&
|
|
getY() == 0 &&
|
|
getZ() == 0;
|
|
}
|
|
|
|
/**
|
|
* Returns if a vector is normalized
|
|
*
|
|
* @return whether the vector is normalised
|
|
*/
|
|
public boolean isNormalized() {
|
|
return Math.abs(this.lengthSquared() - 1) < getEpsilon();
|
|
}
|
|
|
|
/**
|
|
* Rotates the vector around the x axis.
|
|
* <p>
|
|
* This piece of math is based on the standard rotation matrix for vectors
|
|
* in three dimensional space. This matrix can be found here:
|
|
* <a href="https://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">Rotation
|
|
* Matrix</a>.
|
|
*
|
|
* @param angle the angle to rotate the vector about. This angle is passed
|
|
* in radians
|
|
* @return the same vector
|
|
*/
|
|
@NotNull
|
|
public Vector rotateAroundX(double angle) {
|
|
double angleCos = Math.cos(angle);
|
|
double angleSin = Math.sin(angle);
|
|
|
|
this.y = angleCos * getY() - angleSin * getZ();
|
|
this.z = angleSin * getY() + angleCos * getZ();
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Rotates the vector around the y axis.
|
|
* <p>
|
|
* This piece of math is based on the standard rotation matrix for vectors
|
|
* in three dimensional space. This matrix can be found here:
|
|
* <a href="https://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">Rotation
|
|
* Matrix</a>.
|
|
*
|
|
* @param angle the angle to rotate the vector about. This angle is passed
|
|
* in radians
|
|
* @return the same vector
|
|
*/
|
|
@NotNull
|
|
public Vector rotateAroundY(double angle) {
|
|
double angleCos = Math.cos(angle);
|
|
double angleSin = Math.sin(angle);
|
|
|
|
this.x = angleCos * getX() + angleSin * getZ();
|
|
this.z = -angleSin * getX() + angleCos * getZ();
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Rotates the vector around the z axis
|
|
* <p>
|
|
* This piece of math is based on the standard rotation matrix for vectors
|
|
* in three dimensional space. This matrix can be found here:
|
|
* <a href="https://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">Rotation
|
|
* Matrix</a>.
|
|
*
|
|
* @param angle the angle to rotate the vector about. This angle is passed
|
|
* in radians
|
|
* @return the same vector
|
|
*/
|
|
@NotNull
|
|
public Vector rotateAroundZ(double angle) {
|
|
double angleCos = Math.cos(angle);
|
|
double angleSin = Math.sin(angle);
|
|
|
|
this.x = angleCos * getX() - angleSin * getY();
|
|
this.y = angleSin * getX() + angleCos * getY();
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Rotates the vector around a given arbitrary axis in 3 dimensional space.
|
|
*
|
|
* <p>
|
|
* Rotation will follow the general Right-Hand-Rule, which means rotation
|
|
* will be counterclockwise when the axis is pointing towards the observer.
|
|
* <p>
|
|
* This method will always make sure the provided axis is a unit vector, to
|
|
* not modify the length of the vector when rotating. If you are experienced
|
|
* with the scaling of a non-unit axis vector, you can use
|
|
* {@link Vector#rotateAroundNonUnitAxis(Vector, double)}.
|
|
*
|
|
* @param axis the axis to rotate the vector around. If the passed vector is
|
|
* not of length 1, it gets copied and normalized before using it for the
|
|
* rotation. Please use {@link Vector#normalize()} on the instance before
|
|
* passing it to this method
|
|
* @param angle the angle to rotate the vector around the axis
|
|
* @return the same vector
|
|
*/
|
|
@NotNull
|
|
public Vector rotateAroundAxis(@NotNull Vector axis, double angle) throws IllegalArgumentException {
|
|
return rotateAroundNonUnitAxis(axis.isNormalized() ? axis : axis.clone().normalize(), angle);
|
|
}
|
|
|
|
/**
|
|
* Rotates the vector around a given arbitrary axis in 3 dimensional space.
|
|
*
|
|
* <p>
|
|
* Rotation will follow the general Right-Hand-Rule, which means rotation
|
|
* will be counterclockwise when the axis is pointing towards the observer.
|
|
* <p>
|
|
* Note that the vector length will change accordingly to the axis vector
|
|
* length. If the provided axis is not a unit vector, the rotated vector
|
|
* will not have its previous length. The scaled length of the resulting
|
|
* vector will be related to the axis vector. If you are not perfectly sure
|
|
* about the scaling of the vector, use
|
|
* {@link Vector#rotateAroundAxis(Vector, double)}
|
|
*
|
|
* @param axis the axis to rotate the vector around.
|
|
* @param angle the angle to rotate the vector around the axis
|
|
* @return the same vector
|
|
*/
|
|
@NotNull
|
|
public Vector rotateAroundNonUnitAxis(@NotNull Vector axis, double angle) throws IllegalArgumentException {
|
|
double x = getX(), y = getY(), z = getZ();
|
|
double x2 = axis.getX(), y2 = axis.getY(), z2 = axis.getZ();
|
|
|
|
double cosTheta = Math.cos(angle);
|
|
double sinTheta = Math.sin(angle);
|
|
double dotProduct = this.dot(axis);
|
|
|
|
this.x = x2 * dotProduct * (1d - cosTheta)
|
|
+ x * cosTheta
|
|
+ (-z2 * y + y2 * z) * sinTheta;
|
|
this.y = y2 * dotProduct * (1d - cosTheta)
|
|
+ y * cosTheta
|
|
+ (z2 * x - x2 * z) * sinTheta;
|
|
this.z = z2 * dotProduct * (1d - cosTheta)
|
|
+ z * cosTheta
|
|
+ (-y2 * x + x2 * y) * sinTheta;
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object obj) {
|
|
if (!(obj instanceof Vector)) {
|
|
return false;
|
|
}
|
|
|
|
Vector other = (Vector) obj;
|
|
|
|
return Math.abs(x - other.x) < epsilon && Math.abs(y - other.y) < epsilon && Math.abs(z - other.z) < epsilon && (this.getClass().equals(obj.getClass()));
|
|
}
|
|
|
|
/**
|
|
* Returns a hash code for this vector
|
|
*
|
|
* @return hash code
|
|
*/
|
|
@Override
|
|
public int hashCode() {
|
|
int hash = 7;
|
|
|
|
hash = 79 * hash + (int) (Double.doubleToLongBits(this.x) ^ (Double.doubleToLongBits(this.x) >>> 32));
|
|
hash = 79 * hash + (int) (Double.doubleToLongBits(this.y) ^ (Double.doubleToLongBits(this.y) >>> 32));
|
|
hash = 79 * hash + (int) (Double.doubleToLongBits(this.z) ^ (Double.doubleToLongBits(this.z) >>> 32));
|
|
return hash;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "Vector{" +
|
|
"x=" + x +
|
|
", y=" + y +
|
|
", z=" + z +
|
|
'}';
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public Vector clone() {
|
|
try {
|
|
return (Vector) super.clone();
|
|
} catch (CloneNotSupportedException e) {
|
|
MinecraftServer.getExceptionManager().handleException(e);
|
|
throw new IllegalStateException("Weird thing happened");
|
|
}
|
|
}
|
|
|
|
public double getX() {
|
|
return x;
|
|
}
|
|
|
|
public void setX(double x) {
|
|
this.x = x;
|
|
}
|
|
|
|
public double getY() {
|
|
return y;
|
|
}
|
|
|
|
public void setY(double y) {
|
|
this.y = y;
|
|
}
|
|
|
|
public double getZ() {
|
|
return z;
|
|
}
|
|
|
|
public void setZ(double z) {
|
|
this.z = z;
|
|
}
|
|
|
|
/**
|
|
* Gets a new {@link Position} from this vector.
|
|
*
|
|
* @return this vector as a position
|
|
*/
|
|
@NotNull
|
|
public Position toPosition() {
|
|
return new Position(x, y, z);
|
|
}
|
|
|
|
/**
|
|
* Get the threshold used for equals().
|
|
*
|
|
* @return The epsilon.
|
|
*/
|
|
public static double getEpsilon() {
|
|
return epsilon;
|
|
}
|
|
}
|