Vector3 (worldedit-core 7.2.0 API)

java.lang.Object
- com.sk89q.worldedit.math.Vector3

public final class Vector3
extends java.lang.Object

An immutable 3-dimensional vector.

Field Summary

Fields
Modifier and Type Field and Description

static Vector3 ONE

static Vector3 UNIT_X

static Vector3 UNIT_Y

static Vector3 UNIT_Z

static Vector3 ZERO

Fields
Modifier and Type	Field and Description
`static Vector3`	`ONE`
`static Vector3`	`UNIT_X`
`static Vector3`	`UNIT_Y`
`static Vector3`	`UNIT_Z`
`static Vector3`	`ZERO`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Vector3`	`abs()` Returns a vector with the absolute values of the components of this vector.
`Vector3`	`add(double x, double y, double z)` Add another vector to this vector and return the result as a new vector.
`Vector3`	`add(Vector3... others)` Add a list of vectors to this vector and return the result as a new vector.
`Vector3`	`add(Vector3 other)` Add another vector to this vector and return the result as a new vector.
`static Vector3`	`at(double x, double y, double z)`
`Vector3`	`ceil()` Rounds all components up.
`Vector3`	`clampY(int min, int max)` Clamp the Y component.
`boolean`	`containedWithin(Vector3 min, Vector3 max)` Checks to see if a vector is contained with another.
`Vector3`	`cross(Vector3 other)` Gets the cross product of this and another vector.
`double`	`distance(Vector3 other)` Get the distance between this vector and another vector.
`double`	`distanceSq(Vector3 other)` Get the distance between this vector and another vector, squared.
`Vector3`	`divide(double n)` Perform scalar division and return a new vector.
`Vector3`	`divide(double x, double y, double z)` Divide this vector by another vector on each component.
`Vector3`	`divide(Vector3 other)` Divide this vector by another vector on each component.
`double`	`dot(Vector3 other)` Gets the dot product of this and another vector.
`boolean`	`equals(java.lang.Object obj)`
`Vector3`	`floor()` Floors the values of all components.
`Vector3`	`getMaximum(Vector3 v2)` Gets the maximum components of two vectors.
`Vector3`	`getMinimum(Vector3 v2)` Gets the minimum components of two vectors.
`double`	`getX()` Get the X coordinate.
`double`	`getY()` Get the Y coordinate.
`double`	`getZ()` Get the Z coordinate.
`int`	`hashCode()`
`double`	`length()` Get the length of the vector.
`double`	`lengthSq()` Get the length, squared, of the vector.
`Vector3`	`multiply(double n)` Perform scalar multiplication and return a new vector.
`Vector3`	`multiply(double x, double y, double z)` Multiply this vector by another vector on each component.
`Vector3`	`multiply(Vector3... others)` Multiply this vector by zero or more vectors on each component.
`Vector3`	`multiply(Vector3 other)` Multiply this vector by another vector on each component.
`Vector3`	`normalize()` Get the normalized vector, which is the vector divided by its length, as a new vector.
`Vector3`	`round()` Rounds all components to the closest integer.
`static java.util.Comparator<Vector3>`	`sortByCoordsYzx()` Returns a comparator that sorts vectors first by Y, then Z, then X.
`Vector3`	`subtract(double x, double y, double z)` Subtract another vector from this vector and return the result as a new vector.
`Vector3`	`subtract(Vector3... others)` Subtract a list of vectors from this vector and return the result as a new vector.
`Vector3`	`subtract(Vector3 other)` Subtract another vector from this vector and return the result as a new vector.
`BlockVector3`	`toBlockPoint()` Create a new `BlockVector` from this vector.
`static BlockVector3`	`toBlockPoint(double x, double y, double z)` Create a new `BlockVector` using the given components.
`java.lang.String`	`toParserString()` Returns a string representation that is supported by the parser.
`double`	`toPitch()` Get this vector's pitch as used within the game.
`java.lang.String`	`toString()`
`Vector2`	`toVector2()` Creates a 2D vector by dropping the Y component from this vector.
`double`	`toYaw()` Get this vector's yaw as used within the game.
`Vector3`	`transform2D(double angle, double aboutX, double aboutZ, double translateX, double translateZ)` Perform a 2D transformation on this vector and return a new one.
`Vector3`	`withX(double x)` Set the X coordinate.
`Vector3`	`withY(double y)` Set the Y coordinate.
`Vector3`	`withZ(double z)` Set the Z coordinate.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - ZERO
```
public static final Vector3 ZERO
```
  - UNIT_X
```
public static final Vector3 UNIT_X
```
  - UNIT_Y
```
public static final Vector3 UNIT_Y
```
  - UNIT_Z
```
public static final Vector3 UNIT_Z
```
  - ONE
```
public static final Vector3 ONE
```
- Method Detail
  - at
```
public static Vector3 at(double x,
                         double y,
                         double z)
```
  - sortByCoordsYzx
```
public static java.util.Comparator<Vector3> sortByCoordsYzx()
```
    Returns a comparator that sorts vectors first by Y, then Z, then X.
    Useful for sorting by chunk block storage order.
  - getX
```
public double getX()
```
    Get the X coordinate.
    
    Returns:
    
    the x coordinate
  - withX
```
public Vector3 withX(double x)
```
    Set the X coordinate.
    
    Parameters:
    
    x - the new X
    
    Returns:
    
    a new vector
  - getY
```
public double getY()
```
    Get the Y coordinate.
    
    Returns:
    
    the y coordinate
  - withY
```
public Vector3 withY(double y)
```
    Set the Y coordinate.
    
    Parameters:
    
    y - the new Y
    
    Returns:
    
    a new vector
  - getZ
```
public double getZ()
```
    Get the Z coordinate.
    
    Returns:
    
    the z coordinate
  - withZ
```
public Vector3 withZ(double z)
```
    Set the Z coordinate.
    
    Parameters:
    
    z - the new Z
    
    Returns:
    
    a new vector
  - add
```
public Vector3 add(Vector3 other)
```
    Add another vector to this vector and return the result as a new vector.
    
    Parameters:
    
    other - the other vector
    
    Returns:
    
    a new vector
  - add
```
public Vector3 add(double x,
                   double y,
                   double z)
```
    Add another vector to this vector and return the result as a new vector.
    
    Parameters:
    
    x - the value to add
    
    y - the value to add
    
    z - the value to add
    
    Returns:
    
    a new vector
  - add
```
public Vector3 add(Vector3... others)
```
    Add a list of vectors to this vector and return the result as a new vector.
    
    Parameters:
    
    others - an array of vectors
    
    Returns:
    
    a new vector
  - subtract
```
public Vector3 subtract(Vector3 other)
```
    Subtract another vector from this vector and return the result as a new vector.
    
    Parameters:
    
    other - the other vector
    
    Returns:
    
    a new vector
  - subtract
```
public Vector3 subtract(double x,
                        double y,
                        double z)
```
    Subtract another vector from this vector and return the result as a new vector.
    
    Parameters:
    
    x - the value to subtract
    
    y - the value to subtract
    
    z - the value to subtract
    
    Returns:
    
    a new vector
  - subtract
```
public Vector3 subtract(Vector3... others)
```
    Subtract a list of vectors from this vector and return the result as a new vector.
    
    Parameters:
    
    others - an array of vectors
    
    Returns:
    
    a new vector
  - multiply
```
public Vector3 multiply(Vector3 other)
```
    Multiply this vector by another vector on each component.
    
    Parameters:
    
    other - the other vector
    
    Returns:
    
    a new vector
  - multiply
```
public Vector3 multiply(double x,
                        double y,
                        double z)
```
    Multiply this vector by another vector on each component.
    
    Parameters:
    
    x - the value to multiply
    
    y - the value to multiply
    
    z - the value to multiply
    
    Returns:
    
    a new vector
  - multiply
```
public Vector3 multiply(Vector3... others)
```
    Multiply this vector by zero or more vectors on each component.
    
    Parameters:
    
    others - an array of vectors
    
    Returns:
    
    a new vector
  - multiply
```
public Vector3 multiply(double n)
```
    Perform scalar multiplication and return a new vector.
    
    Parameters:
    
    n - the value to multiply
    
    Returns:
    
    a new vector
  - divide
```
public Vector3 divide(Vector3 other)
```
    Divide this vector by another vector on each component.
    
    Parameters:
    
    other - the other vector
    
    Returns:
    
    a new vector
  - divide
```
public Vector3 divide(double x,
                      double y,
                      double z)
```
    Divide this vector by another vector on each component.
    
    Parameters:
    
    x - the value to divide by
    
    y - the value to divide by
    
    z - the value to divide by
    
    Returns:
    
    a new vector
  - divide
```
public Vector3 divide(double n)
```
    Perform scalar division and return a new vector.
    
    Parameters:
    
    n - the value to divide by
    
    Returns:
    
    a new vector
  - length
```
public double length()
```
    Get the length of the vector.
    
    Returns:
    
    length
  - lengthSq
```
public double lengthSq()
```
    Get the length, squared, of the vector.
    
    Returns:
    
    length, squared
  - distance
```
public double distance(Vector3 other)
```
    Get the distance between this vector and another vector.
    
    Parameters:
    
    other - the other vector
    
    Returns:
    
    distance
  - distanceSq
```
public double distanceSq(Vector3 other)
```
    Get the distance between this vector and another vector, squared.
    
    Parameters:
    
    other - the other vector
    
    Returns:
    
    distance
  - normalize
```
public Vector3 normalize()
```
    Get the normalized vector, which is the vector divided by its length, as a new vector.
    
    Returns:
    
    a new vector
  - dot
```
public double dot(Vector3 other)
```
    Gets the dot product of this and another vector.
    
    Parameters:
    
    other - the other vector
    
    Returns:
    
    the dot product of this and the other vector
  - cross
```
public Vector3 cross(Vector3 other)
```
    Gets the cross product of this and another vector.
    
    Parameters:
    
    other - the other vector
    
    Returns:
    
    the cross product of this and the other vector
  - containedWithin
```
public boolean containedWithin(Vector3 min,
                               Vector3 max)
```
    Checks to see if a vector is contained with another.
    
    Parameters:
    
    min - the minimum point (X, Y, and Z are the lowest)
    
    max - the maximum point (X, Y, and Z are the lowest)
    
    Returns:
    
    true if the vector is contained
  - clampY
```
public Vector3 clampY(int min,
                      int max)
```
    Clamp the Y component.
    
    Parameters:
    
    min - the minimum value
    
    max - the maximum value
    
    Returns:
    
    a new vector
  - floor
```
public Vector3 floor()
```
    Floors the values of all components.
    
    Returns:
    
    a new vector
  - ceil
```
public Vector3 ceil()
```
    Rounds all components up.
    
    Returns:
    
    a new vector
  - round
```
public Vector3 round()
```
    Rounds all components to the closest integer.
    Components < 0.5 are rounded down, otherwise up.
    
    Returns:
    
    a new vector
  - abs
```
public Vector3 abs()
```
    Returns a vector with the absolute values of the components of this vector.
    
    Returns:
    
    a new vector
  - transform2D
```
public Vector3 transform2D(double angle,
                           double aboutX,
                           double aboutZ,
                           double translateX,
                           double translateZ)
```
    Perform a 2D transformation on this vector and return a new one.
    
    Parameters:
    
    angle - in degrees
    
    aboutX - about which x coordinate to rotate
    
    aboutZ - about which z coordinate to rotate
    
    translateX - what to add after rotation
    
    translateZ - what to add after rotation
    
    Returns:
    
    a new vector
    
    See Also:
    
    another method to transform vectors
  - toPitch
```
public double toPitch()
```
    Get this vector's pitch as used within the game.
    
    Returns:
    
    pitch in radians
  - toYaw
```
public double toYaw()
```
    Get this vector's yaw as used within the game.
    
    Returns:
    
    yaw in radians
  - getMinimum
```
public Vector3 getMinimum(Vector3 v2)
```
    Gets the minimum components of two vectors.
    
    Parameters:
    
    v2 - the second vector
    
    Returns:
    
    minimum
  - getMaximum
```
public Vector3 getMaximum(Vector3 v2)
```
    Gets the maximum components of two vectors.
    
    Parameters:
    
    v2 - the second vector
    
    Returns:
    
    maximum
  - toBlockPoint
```
public static BlockVector3 toBlockPoint(double x,
                                        double y,
                                        double z)
```
    Create a new BlockVector using the given components.
    
    Parameters:
    
    x - the X coordinate
    
    y - the Y coordinate
    
    z - the Z coordinate
    
    Returns:
    
    a new BlockVector
  - toBlockPoint
```
public BlockVector3 toBlockPoint()
```
    Create a new BlockVector from this vector.
    
    Returns:
    
    a new BlockVector
  - toVector2
```
public Vector2 toVector2()
```
    Creates a 2D vector by dropping the Y component from this vector.
    
    Returns:
    
    a new Vector2
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - toParserString
```
public java.lang.String toParserString()
```
    Returns a string representation that is supported by the parser.
    
    Returns:
    
    string

Class Vector3

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ZERO

UNIT_X

UNIT_Y

UNIT_Z

ONE

Method Detail

at

sortByCoordsYzx

getX

withX

getY

withY

getZ

withZ

add

add

add

subtract

subtract

subtract

multiply

multiply

multiply

multiply

divide

divide

divide

length

lengthSq

distance

distanceSq

normalize

dot

cross

containedWithin

clampY

floor

ceil

round

abs

transform2D

toPitch

toYaw

getMinimum

getMaximum

toBlockPoint

toBlockPoint

toVector2

equals

hashCode

toString

toParserString