public class Vector2 extends Object implements Serializable, Vector<Vector2>
Modifier and Type | Field and Description |
---|---|
float |
x
the x-component of this vector
|
static Vector2 |
X |
float |
y
the y-component of this vector
|
static Vector2 |
Y |
static Vector2 |
Zero |
Constructor and Description |
---|
Vector2()
Constructs a new vector at (0,0)
|
Vector2(float x,
float y)
Constructs a vector with the given components
|
Vector2(Vector2 v)
Constructs a vector from the given vector
|
Modifier and Type | Method and Description |
---|---|
Vector2 |
add(float x,
float y)
Adds the given components to this vector
|
Vector2 |
add(Vector2 v)
Adds the given vector to this vector
|
float |
angle() |
float |
angle(Vector2 reference) |
float |
angleRad() |
float |
angleRad(Vector2 reference) |
Vector2 |
clamp(float min,
float max)
Clamps this vector's length to given min and max values
|
Vector2 |
cpy() |
float |
crs(float x,
float y)
Calculates the 2D cross product between this and the given vector.
|
float |
crs(Vector2 v)
Calculates the 2D cross product between this and the given vector.
|
float |
dot(float ox,
float oy) |
static float |
dot(float x1,
float y1,
float x2,
float y2) |
float |
dot(Vector2 v) |
float |
dst(float x,
float y) |
static float |
dst(float x1,
float y1,
float x2,
float y2) |
float |
dst(Vector2 v) |
float |
dst2(float x,
float y) |
static float |
dst2(float x1,
float y1,
float x2,
float y2) |
float |
dst2(Vector2 v)
This method is faster than
Vector.dst(Vector) because it avoids calculating a square root. |
boolean |
epsilonEquals(float x,
float y)
Compares this vector with the other vector using MathUtils.FLOAT_ROUNDING_ERROR for fuzzy equality testing
|
boolean |
epsilonEquals(float x,
float y,
float epsilon)
Compares this vector with the other vector, using the supplied epsilon for fuzzy equality testing.
|
boolean |
epsilonEquals(Vector2 other)
Compares this vector with the other vector using MathUtils.FLOAT_ROUNDING_ERROR for fuzzy equality testing
|
boolean |
epsilonEquals(Vector2 other,
float epsilon)
Compares this vector with the other vector, using the supplied epsilon for fuzzy equality testing.
|
boolean |
equals(Object obj) |
Vector2 |
fromString(String v)
Sets this
Vector2 to the value represented by the specified string according to the format of toString() . |
int |
hashCode() |
boolean |
hasOppositeDirection(Vector2 vector) |
boolean |
hasSameDirection(Vector2 vector) |
Vector2 |
interpolate(Vector2 target,
float alpha,
Interpolation interpolation)
Interpolates between this vector and the given target vector by alpha (within range [0,1]) using the given Interpolation
method.
|
boolean |
isCollinear(Vector2 other) |
boolean |
isCollinear(Vector2 other,
float epsilon) |
boolean |
isCollinearOpposite(Vector2 other) |
boolean |
isCollinearOpposite(Vector2 other,
float epsilon) |
boolean |
isOnLine(Vector2 other) |
boolean |
isOnLine(Vector2 other,
float epsilon) |
boolean |
isPerpendicular(Vector2 vector) |
boolean |
isPerpendicular(Vector2 vector,
float epsilon) |
boolean |
isUnit() |
boolean |
isUnit(float margin) |
boolean |
isZero() |
boolean |
isZero(float margin) |
float |
len() |
static float |
len(float x,
float y) |
float |
len2()
This method is faster than
Vector.len() because it avoids calculating a square root. |
static float |
len2(float x,
float y) |
Vector2 |
lerp(Vector2 target,
float alpha)
Linearly interpolates between this vector and the target vector by alpha which is in the range [0,1].
|
Vector2 |
limit(float limit)
Limits the length of this vector, based on the desired maximum length.
|
Vector2 |
limit2(float limit2)
Limits the length of this vector, based on the desired maximum length squared.
|
Vector2 |
mul(Matrix3 mat)
Left-multiplies this vector by the given matrix
|
Vector2 |
mulAdd(Vector2 vec,
float scalar)
First scale a supplied vector, then add it to this vector.
|
Vector2 |
mulAdd(Vector2 vec,
Vector2 mulVec)
First scale a supplied vector, then add it to this vector.
|
Vector2 |
nor()
Normalizes this vector.
|
Vector2 |
rotate(float degrees)
Rotates the Vector2 by the given angle, counter-clockwise assuming the y-axis points up.
|
Vector2 |
rotate90(int dir)
Rotates the Vector2 by 90 degrees in the specified direction, where >= 0 is counter-clockwise and < 0 is clockwise.
|
Vector2 |
rotateAround(Vector2 reference,
float degrees)
Rotates the Vector2 by the given angle around reference vector, counter-clockwise assuming the y-axis points up.
|
Vector2 |
rotateAroundRad(Vector2 reference,
float radians)
Rotates the Vector2 by the given angle around reference vector, counter-clockwise assuming the y-axis points up.
|
Vector2 |
rotateRad(float radians)
Rotates the Vector2 by the given angle, counter-clockwise assuming the y-axis points up.
|
Vector2 |
scl(float scalar)
Scales this vector by a scalar
|
Vector2 |
scl(float x,
float y)
Multiplies this vector by a scalar
|
Vector2 |
scl(Vector2 v)
Scales this vector by another vector
|
Vector2 |
set(float x,
float y)
Sets the components of this vector
|
Vector2 |
set(Vector2 v)
Sets this vector from the given vector
|
Vector2 |
setAngle(float degrees)
Sets the angle of the vector in degrees relative to the x-axis, towards the positive y-axis (typically counter-clockwise).
|
Vector2 |
setAngleRad(float radians)
Sets the angle of the vector in radians relative to the x-axis, towards the positive y-axis (typically counter-clockwise).
|
Vector2 |
setLength(float len)
Sets the length of this vector.
|
Vector2 |
setLength2(float len2)
Sets the length of this vector, based on the square of the desired length.
|
Vector2 |
setToRandomDirection()
Sets this vector to the unit vector with a random direction
|
Vector2 |
setZero()
Sets the components of this vector to 0
|
Vector2 |
sub(float x,
float y)
Substracts the other vector from this vector.
|
Vector2 |
sub(Vector2 v)
Subtracts the given vector from this vector.
|
String |
toString()
Converts this
Vector2 to a string in the format (x,y) . |
public static final Vector2 X
public static final Vector2 Y
public static final Vector2 Zero
public float x
public float y
public Vector2()
public Vector2(float x, float y)
x
- The x-componenty
- The y-componentpublic Vector2(Vector2 v)
v
- The vectorpublic Vector2 cpy()
public static float len(float x, float y)
public static float len2(float x, float y)
public float len2()
Vector
Vector.len()
because it avoids calculating a square root. It is useful for comparisons,
but not for getting exact lengths, as the return value is the square of the actual length.public Vector2 set(Vector2 v)
Vector
public Vector2 set(float x, float y)
x
- The x-componenty
- The y-componentpublic Vector2 sub(Vector2 v)
Vector
public Vector2 sub(float x, float y)
x
- The x-component of the other vectory
- The y-component of the other vectorpublic Vector2 nor()
Vector
public Vector2 add(Vector2 v)
Vector
public Vector2 add(float x, float y)
x
- The x-componenty
- The y-componentpublic static float dot(float x1, float y1, float x2, float y2)
public float dot(Vector2 v)
public float dot(float ox, float oy)
public Vector2 scl(float scalar)
Vector
public Vector2 scl(float x, float y)
public Vector2 scl(Vector2 v)
Vector
public Vector2 mulAdd(Vector2 vec, float scalar)
Vector
public Vector2 mulAdd(Vector2 vec, Vector2 mulVec)
Vector
public static float dst(float x1, float y1, float x2, float y2)
public float dst(Vector2 v)
public float dst(float x, float y)
x
- The x-component of the other vectory
- The y-component of the other vectorpublic static float dst2(float x1, float y1, float x2, float y2)
public float dst2(Vector2 v)
Vector
Vector.dst(Vector)
because it avoids calculating a square root. It is useful for
comparisons, but not for getting accurate distances, as the return value is the square of the actual distance.public float dst2(float x, float y)
x
- The x-component of the other vectory
- The y-component of the other vectorpublic Vector2 limit(float limit)
Vector
public Vector2 limit2(float limit2)
Vector
limit2
in interface Vector<Vector2>
limit2
- squared desired maximum length for this vectorVector.len2()
public Vector2 clamp(float min, float max)
Vector
public Vector2 setLength(float len)
Vector
public Vector2 setLength2(float len2)
Vector
setLength2
in interface Vector<Vector2>
len2
- desired square of the length for this vectorVector.len2()
public String toString()
Vector2
to a string in the format (x,y)
.public Vector2 fromString(String v)
Vector2
to the value represented by the specified string according to the format of toString()
.v
- the string.public Vector2 mul(Matrix3 mat)
mat
- the matrixpublic float crs(Vector2 v)
v
- the other vectorpublic float crs(float x, float y)
x
- the x-coordinate of the other vectory
- the y-coordinate of the other vectorpublic float angle()
public float angle(Vector2 reference)
public float angleRad()
public float angleRad(Vector2 reference)
public Vector2 setAngle(float degrees)
degrees
- The angle in degrees to set.public Vector2 setAngleRad(float radians)
radians
- The angle in radians to set.public Vector2 rotate(float degrees)
degrees
- the angle in degreespublic Vector2 rotateAround(Vector2 reference, float degrees)
degrees
- the angle in degreesreference
- center Vector2public Vector2 rotateRad(float radians)
radians
- the angle in radianspublic Vector2 rotateAroundRad(Vector2 reference, float radians)
radians
- the angle in radiansreference
- center Vector2public Vector2 rotate90(int dir)
public Vector2 lerp(Vector2 target, float alpha)
Vector
public Vector2 interpolate(Vector2 target, float alpha, Interpolation interpolation)
Vector
interpolate
in interface Vector<Vector2>
target
- The target vectoralpha
- The interpolation coefficientinterpolation
- An Interpolation object describing the used interpolation methodpublic Vector2 setToRandomDirection()
Vector
setToRandomDirection
in interface Vector<Vector2>
public boolean epsilonEquals(Vector2 other, float epsilon)
Vector
epsilonEquals
in interface Vector<Vector2>
public boolean epsilonEquals(float x, float y, float epsilon)
public boolean epsilonEquals(Vector2 other)
other
- other vector to comparepublic boolean epsilonEquals(float x, float y)
x
- x component of the other vector to comparey
- y component of the other vector to comparepublic boolean isUnit()
public boolean isUnit(float margin)
public boolean isZero()
public boolean isZero(float margin)
public boolean isOnLine(Vector2 other)
public boolean isOnLine(Vector2 other, float epsilon)
public boolean isCollinear(Vector2 other, float epsilon)
isCollinear
in interface Vector<Vector2>
Vector.isOnLine(Vector, float)
&&
Vector.hasSameDirection(Vector)
).public boolean isCollinear(Vector2 other)
isCollinear
in interface Vector<Vector2>
Vector.isOnLine(Vector)
&&
Vector.hasSameDirection(Vector)
).public boolean isCollinearOpposite(Vector2 other, float epsilon)
isCollinearOpposite
in interface Vector<Vector2>
Vector.isOnLine(Vector, float)
&&
Vector.hasOppositeDirection(Vector)
).public boolean isCollinearOpposite(Vector2 other)
isCollinearOpposite
in interface Vector<Vector2>
Vector.isOnLine(Vector)
&&
Vector.hasOppositeDirection(Vector)
).public boolean isPerpendicular(Vector2 vector)
isPerpendicular
in interface Vector<Vector2>
public boolean isPerpendicular(Vector2 vector, float epsilon)
isPerpendicular
in interface Vector<Vector2>
epsilon
- a positive small number close to zeropublic boolean hasSameDirection(Vector2 vector)
hasSameDirection
in interface Vector<Vector2>
public boolean hasOppositeDirection(Vector2 vector)
hasOppositeDirection
in interface Vector<Vector2>
Copyright © 2019. All rights reserved.