toxi.geom
Class Vec3D

java.lang.Object
  extended by toxi.geom.Vec3D
All Implemented Interfaces:
java.lang.Comparable<Vec3D>
Direct Known Subclasses:
AABB, Cone, Plane, Ray3D, Sphere, TriangleMesh.Vertex

public class Vec3D
extends java.lang.Object
implements java.lang.Comparable<Vec3D>

Comprehensive 3D vector class with additional basic intersection and collision detection features.

Author:
Karsten Schmidt

Nested Class Summary
static class Vec3D.Axis
           
 
Field Summary
static Vec3D MAX_VALUE
          Defines vector with all coords set to Float.MAX_VALUE.
static Vec3D MIN_VALUE
          Defines vector with all coords set to Float.MIN_VALUE.
 float x
          X coordinate.
static Vec3D X_AXIS
          Defines positive X axis.
 float y
          Y coordinate.
static Vec3D Y_AXIS
          Defines positive Y axis.
 float z
          Z coordinate.
static Vec3D Z_AXIS
          Defines positive Z axis.
static Vec3D ZERO
          Defines the zero vector.
 
Constructor Summary
Vec3D()
          Creates a new zero vector.
Vec3D(float x, float y, float z)
          Creates a new vector with the given coordinates.
Vec3D(Vec3D v)
          Creates a new vector with the coordinates of the given vector.
 
Method Summary
 Vec3D abs()
          Abs.
 Vec3D add(float a, float b, float c)
          Adds vector {a,b,c} and returns result as new vector.
 Vec3D add(Vec3D v)
          Add vector v and returns result as new vector.
 Vec3D addSelf(float a, float b, float c)
          Adds vector {a,b,c} and overrides coordinates with result.
 Vec3D addSelf(Vec3D v)
          Adds vector v and overrides coordinates with result.
 float angleBetween(Vec3D v)
          Computes the angle between this vector and vector V.
 float angleBetween(Vec3D v, boolean forceNormalize)
          Computes the angle between this vector and vector V.
 Vec3D clear()
          Sets all vector components to 0.
 Vec3D closestPointOnLine(Vec3D a, Vec3D b)
          Computes the closest point on the given line segments.
 int compareTo(Vec3D v)
          Compares the length of the vector with another one.
 Vec3D constrain(AABB box)
          Forcefully fits the vector in the given AABB.
 Vec3D constrain(Vec3D min, Vec3D max)
          Forcefully fits the vector in the given AABB specified by the 2 given points.
 Vec3D copy()
          Copy.
 Vec3D cross(Vec3D v)
          Calculates cross-product with vector v.
 Vec3D crossInto(Vec3D v, Vec3D result)
          Calculates cross-product with vector v.
 Vec3D crossSelf(Vec3D v)
          Calculates cross-product with vector v.
 float distanceTo(Vec3D v)
          Calculates distance to another vector.
 float distanceToSquared(Vec3D v)
          Calculates the squared distance to another vector.
 float dot(Vec3D v)
          Computes the scalar product (dot product) with the given vector.
 boolean equals(java.lang.Object obj)
           
 boolean equalsWithTolerance(Vec3D v, float tolerance)
          Compares this vector with the one given.
 Vec3D floor()
          Replaces the vector components with integer values of their current values.
 Vec3D frac()
          Replaces the vector components with the fractional part of their current values.
static Vec3D fromXYTheta(float theta)
          Creates a new vector from the given angle in the XY plane.
static Vec3D fromXZTheta(float theta)
          Creates a new vector from the given angle in the XZ plane.
static Vec3D fromYZTheta(float theta)
          Creates a new vector from the given angle in the YZ plane.
 Vec3D getAbs()
          Gets the abs.
 float getComponent(Vec3D.Axis id)
           
 Vec3D getConstrained(AABB box)
          Creates a copy of the vector which forcefully fits in the given AABB.
 Vec3D getFloored()
          Creates a new vector whose components are the integer value of their current values.
 Vec3D getFrac()
          Creates a new vector whose components are the fractional part of their current values.
 Vec3D getInverted()
          Scales vector uniformly by factor -1 ( v = -v ).
 Vec3D getLimited(float lim)
          Creates a copy of the vector with its magnitude limited to the length given.
 Vec3D getNormalized()
          Produces the normalized version as a new vector.
 Vec3D getNormalizedTo(float len)
          Produces a new vector normalized to the given length.
 Vec3D getReciprocal()
          Returns a multiplicative inverse copy of the vector.
 Vec3D getRotatedAroundAxis(Vec3D axis, float theta)
          Gets the rotated around axis.
 Vec3D getRotatedX(float theta)
          Creates a new vector rotated by the given angle around the X axis.
 Vec3D getRotatedY(float theta)
          Creates a new vector rotated by the given angle around the Y axis.
 Vec3D getRotatedZ(float theta)
          Creates a new vector rotated by the given angle around the Z axis.
 Vec3D getSignum()
          Creates a new vector in which all components are replaced with the signum of their original values.
 int hashCode()
          Returns a unique code for this vector object based on it's values.
 float headingXY()
          Computes the vector's direction in the XY plane (for example for 2D points).
 float headingXZ()
          Computes the vector's direction in the XZ plane.
 float headingYZ()
          Computes the vector's direction in the YZ plane.
 Vec3D interpolateTo(Vec3D v, float f)
          Interpolates the vector towards the given target vector, using linear interpolation.
 Vec3D interpolateTo(Vec3D v, float f, InterpolateStrategy s)
          Interpolates the vector towards the given target vector, using the given InterpolateStrategy.
 Vec3D interpolateToSelf(Vec3D v, float f)
          Interpolates the vector towards the given target vector, using linear interpolation.
 Vec3D interpolateToSelf(Vec3D v, float f, InterpolateStrategy s)
          Interpolates the vector towards the given target vector, using the given InterpolateStrategy.
 Vec3D invert()
          Scales vector uniformly by factor -1 ( v = -v ), overrides coordinates with result.
 boolean isInAABB(AABB box)
          Checks if the point is inside the given AABB.
 boolean isInAABB(Vec3D boxOrigin, Vec3D boxExtent)
          Checks if the point is inside the given axis-aligned bounding box.
 boolean isZeroVector()
          Checks if vector has a magnitude equals or close to zero.
 Vec3D jitter(float j)
          Jitter.
 Vec3D jitter(float jx, float jy, float jz)
          Adds random jitter to the vector.
 Vec3D jitter(Vec3D jitterVec)
          Jitter.
 Vec3D limit(float lim)
          Limits the vector's magnitude to the length given.
 float magnitude()
          Calculates the magnitude/eucledian length of the vector.
 float magSquared()
          Calculates only the squared magnitude/length of the vector.
static Vec3D max(Vec3D a, Vec3D b)
          Constructs a new vector consisting of the largest components of both vectors.
 Vec3D maxSelf(Vec3D b)
          Max self.
static Vec3D min(Vec3D a, Vec3D b)
          Constructs a new vector consisting of the smallest components of both vectors.
 Vec3D minSelf(Vec3D b)
          Min self.
 Vec3D modSelf(float base)
          Applies a uniform modulo operation to the vector, using the same base for all components.
 Vec3D modSelf(float bx, float by, float bz)
          Calculates modulo operation for each vector component separately.
 Vec3D normalize()
          Normalizes the vector so that its magnitude = 1.
 Vec3D normalizeTo(float len)
          Normalizes the vector to the given length.
static Vec3D randomVector()
          Static factory method.
static Vec3D randomVector(java.util.Random rnd)
          Static factory method.
 Vec3D reciprocal()
          Replaces the vector components with their multiplicative inverse.
 Vec3D rotateAroundAxis(Vec3D axis, float theta)
          Rotates the vector around the giving axis.
 Vec3D rotateX(float theta)
          Rotates the vector by the given angle around the X axis.
 Vec3D rotateY(float theta)
          Rotates the vector by the given angle around the Y axis.
 Vec3D rotateZ(float theta)
          Rotates the vector by the given angle around the Z axis.
 Vec3D scale(float s)
          Scales vector uniformly and returns result as new vector.
 Vec3D scale(float a, float b, float c)
          Scales vector non-uniformly and returns result as new vector.
 Vec3D scale(Vec3D s)
          Scales vector non-uniformly by vector v and returns result as new vector.
 Vec3D scaleSelf(float s)
          Scales vector uniformly and overrides coordinates with result.
 Vec3D scaleSelf(float a, float b, float c)
          Scales vector non-uniformly by vector {a,b,c} and overrides coordinates with result.
 Vec3D scaleSelf(Vec3D s)
          Scales vector non-uniformly by vector v and overrides coordinates with result.
 Vec3D set(float x, float y, float z)
          Overrides coordinates with the given values.
 Vec3D set(Vec3D v)
          Overrides coordinates with the ones of the given vector.
 Vec3D setComponent(Vec3D.Axis id, float val)
           
 Vec3D setXY(Vec2D v)
          Overrides XY coordinates with the ones of the given 2D vector.
 Vec3D signum()
          Replaces all vector components with the signum of their original values.
 Vec3D sub(float a, float b, float c)
          Subtracts vector {a,b,c} and returns result as new vector.
 Vec3D sub(Vec3D v)
          Subtracts vector v and returns result as new vector.
 Vec3D subSelf(float a, float b, float c)
          Subtracts vector {a,b,c} and overrides coordinates with result.
 Vec3D subSelf(Vec3D v)
          Subtracts vector v and overrides coordinates with result.
 Vec2D to2DXY()
          Creates a new 2D vector of the XY components.
 Vec2D to2DXZ()
          Creates a new 2D vector of the XZ components.
 Vec2D to2DYZ()
          Creates a new 2D vector of the YZ components.
 float[] toArray()
           
 Vec3D toCartesian()
          Converts the spherical vector back into cartesian coordinates.
 Vec3D toSpherical()
          Converts the vector into spherical coordinates.
 java.lang.String toString()
           
 
Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait
 

Field Detail

X_AXIS

public static final Vec3D X_AXIS
Defines positive X axis.


Y_AXIS

public static final Vec3D Y_AXIS
Defines positive Y axis.


Z_AXIS

public static final Vec3D Z_AXIS
Defines positive Z axis.


ZERO

public static final Vec3D ZERO
Defines the zero vector.


MIN_VALUE

public static final Vec3D MIN_VALUE
Defines vector with all coords set to Float.MIN_VALUE. Useful for bounding box operations.


MAX_VALUE

public static final Vec3D MAX_VALUE
Defines vector with all coords set to Float.MAX_VALUE. Useful for bounding box operations.


x

public float x
X coordinate.


y

public float y
Y coordinate.


z

public float z
Z coordinate.

Constructor Detail

Vec3D

public Vec3D()
Creates a new zero vector.


Vec3D

public Vec3D(float x,
             float y,
             float z)
Creates a new vector with the given coordinates.

Parameters:
x - the x
y - the y
z - the z

Vec3D

public Vec3D(Vec3D v)
Creates a new vector with the coordinates of the given vector.

Parameters:
v - vector to be copied
Method Detail

fromXYTheta

public static final Vec3D fromXYTheta(float theta)
Creates a new vector from the given angle in the XY plane. The Z component of the vector will be zero. The resulting vector for theta=0 is equal to the positive X axis.

Parameters:
theta - the theta
Returns:
new vector in the XY plane

fromXZTheta

public static final Vec3D fromXZTheta(float theta)
Creates a new vector from the given angle in the XZ plane. The Y component of the vector will be zero. The resulting vector for theta=0 is equal to the positive X axis.

Parameters:
theta - the theta
Returns:
new vector in the XZ plane

fromYZTheta

public static final Vec3D fromYZTheta(float theta)
Creates a new vector from the given angle in the YZ plane. The X component of the vector will be zero. The resulting vector for theta=0 is equal to the positive Y axis.

Parameters:
theta - the theta
Returns:
new vector in the YZ plane

max

public static final Vec3D max(Vec3D a,
                              Vec3D b)
Constructs a new vector consisting of the largest components of both vectors.

Parameters:
b - the b
a - the a
Returns:
result as new vector

min

public static final Vec3D min(Vec3D a,
                              Vec3D b)
Constructs a new vector consisting of the smallest components of both vectors.

Parameters:
b - comparing vector
a - the a
Returns:
result as new vector

randomVector

public static final Vec3D randomVector()
Static factory method. Creates a new random unit vector using the default Math.random() Random instance.

Returns:
a new random normalized unit vector.

randomVector

public static final Vec3D randomVector(java.util.Random rnd)
Static factory method. Creates a new random unit vector using the given Random generator instance. I recommend to have a look at the https://uncommons-maths.dev.java.net library for a good choice of reliable and high quality random number generators.

Parameters:
rnd - the rnd
Returns:
a new random normalized unit vector.

abs

public final Vec3D abs()
Abs.

Returns:
the vec3 d

add

public final Vec3D add(float a,
                       float b,
                       float c)
Adds vector {a,b,c} and returns result as new vector.

Parameters:
a - X coordinate
b - Y coordinate
c - Z coordinate
Returns:
result as new vector

add

public final Vec3D add(Vec3D v)
Add vector v and returns result as new vector.

Parameters:
v - vector to add
Returns:
result as new vector

addSelf

public final Vec3D addSelf(float a,
                           float b,
                           float c)
Adds vector {a,b,c} and overrides coordinates with result.

Parameters:
a - X coordinate
b - Y coordinate
c - Z coordinate
Returns:
itself

addSelf

public final Vec3D addSelf(Vec3D v)
Adds vector v and overrides coordinates with result.

Parameters:
v - vector to add
Returns:
itself

angleBetween

public final float angleBetween(Vec3D v)
Computes the angle between this vector and vector V. This function assumes both vectors are normalized, if this can't be guaranteed, use the alternative implementation angleBetween(Vec3D, boolean)

Parameters:
v - vector
Returns:
angle in radians, or NaN if vectors are parallel

angleBetween

public final float angleBetween(Vec3D v,
                                boolean forceNormalize)
Computes the angle between this vector and vector V.

Parameters:
v - vector
forceNormalize - true, if normalized versions of the vectors are to be used (Note: only copies will be used, original vectors will not be altered by this method)
Returns:
angle in radians, or NaN if vectors are parallel

clear

public final Vec3D clear()
Sets all vector components to 0.

Returns:
itself

closestPointOnLine

public Vec3D closestPointOnLine(Vec3D a,
                                Vec3D b)
Computes the closest point on the given line segments. Helper function for Triangle.getClosestVertexTo(Vec3D)

Parameters:
a - start point of line segment
b - end point of line segment
Returns:
closest point on the line segment a -> b

compareTo

public int compareTo(Vec3D v)
Compares the length of the vector with another one.

Specified by:
compareTo in interface java.lang.Comparable<Vec3D>
Parameters:
v - vector to compare with
Returns:
-1 if other vector is longer, 0 if both are equal or else +1

constrain

public final Vec3D constrain(AABB box)
Forcefully fits the vector in the given AABB.

Parameters:
box - the box
Returns:
itself

constrain

public final Vec3D constrain(Vec3D min,
                             Vec3D max)
Forcefully fits the vector in the given AABB specified by the 2 given points.

Parameters:
min -
max -
Returns:
itself

copy

public Vec3D copy()
Copy.

Returns:
a new independent instance/copy of a given vector

cross

public final Vec3D cross(Vec3D v)
Calculates cross-product with vector v. The resulting vector is perpendicular to both the current and supplied vector.

Parameters:
v - vector to cross
Returns:
cross-product as new vector

crossInto

public final Vec3D crossInto(Vec3D v,
                             Vec3D result)
Calculates cross-product with vector v. The resulting vector is perpendicular to both the current and supplied vector and stored in the supplied result vector.

Parameters:
v - vector to cross
result - result vector
Returns:
result vector

crossSelf

public final Vec3D crossSelf(Vec3D v)
Calculates cross-product with vector v. The resulting vector is perpendicular to both the current and supplied vector and overrides the current.

Parameters:
v - the v
Returns:
itself

distanceTo

public final float distanceTo(Vec3D v)
Calculates distance to another vector.

Parameters:
v - non-null vector
Returns:
distance or Float.NaN if v=null

distanceToSquared

public final float distanceToSquared(Vec3D v)
Calculates the squared distance to another vector.

Parameters:
v - non-null vector
Returns:
distance or NaN if v=null
See Also:
magSquared()

dot

public final float dot(Vec3D v)
Computes the scalar product (dot product) with the given vector.

Parameters:
v - the v
Returns:
dot product
See Also:
Wikipedia entry

equals

public boolean equals(java.lang.Object obj)
Overrides:
equals in class java.lang.Object

equalsWithTolerance

public boolean equalsWithTolerance(Vec3D v,
                                   float tolerance)
Compares this vector with the one given. The vectors are deemed equal if the individual differences of all component values are within the given tolerance.

Parameters:
v - the v
tolerance - the tolerance
Returns:
true, if equal

floor

public final Vec3D floor()
Replaces the vector components with integer values of their current values.

Returns:
itself

frac

public final Vec3D frac()
Replaces the vector components with the fractional part of their current values.

Returns:
itself

getAbs

public final Vec3D getAbs()
Gets the abs.

Returns:
the abs

getComponent

public float getComponent(Vec3D.Axis id)

getConstrained

public final Vec3D getConstrained(AABB box)
Creates a copy of the vector which forcefully fits in the given AABB.

Parameters:
box - the box
Returns:
fitted vector

getFloored

public final Vec3D getFloored()
Creates a new vector whose components are the integer value of their current values.

Returns:
result as new vector

getFrac

public final Vec3D getFrac()
Creates a new vector whose components are the fractional part of their current values.

Returns:
result as new vector

getInverted

public final Vec3D getInverted()
Scales vector uniformly by factor -1 ( v = -v ).

Returns:
result as new vector

getLimited

public final Vec3D getLimited(float lim)
Creates a copy of the vector with its magnitude limited to the length given.

Parameters:
lim - new maximum magnitude
Returns:
result as new vector

getNormalized

public Vec3D getNormalized()
Produces the normalized version as a new vector.

Returns:
new vector

getNormalizedTo

public Vec3D getNormalizedTo(float len)
Produces a new vector normalized to the given length.

Parameters:
len - new desired length
Returns:
new vector

getReciprocal

public final Vec3D getReciprocal()
Returns a multiplicative inverse copy of the vector.

Returns:
new vector

getRotatedAroundAxis

public final Vec3D getRotatedAroundAxis(Vec3D axis,
                                        float theta)
Gets the rotated around axis.

Parameters:
axis - the axis
theta - the theta
Returns:
new result vector
See Also:
rotateAroundAxis(Vec3D, float)

getRotatedX

public final Vec3D getRotatedX(float theta)
Creates a new vector rotated by the given angle around the X axis.

Parameters:
theta - the theta
Returns:
rotated vector

getRotatedY

public final Vec3D getRotatedY(float theta)
Creates a new vector rotated by the given angle around the Y axis.

Parameters:
theta - the theta
Returns:
rotated vector

getRotatedZ

public final Vec3D getRotatedZ(float theta)
Creates a new vector rotated by the given angle around the Z axis.

Parameters:
theta - the theta
Returns:
rotated vector

getSignum

public final Vec3D getSignum()
Creates a new vector in which all components are replaced with the signum of their original values. In other words if a components value was negative its new value will be -1, if zero => 0, if positive => +1

Returns:
result vector

hashCode

public int hashCode()
Returns a unique code for this vector object based on it's values. If two vectors are logically equivalent, they will return the same hash code value.

Overrides:
hashCode in class java.lang.Object
Returns:
the hash code value of this vector.

headingXY

public final float headingXY()
Computes the vector's direction in the XY plane (for example for 2D points). The positive X axis equals 0 degrees.

Returns:
rotation angle

headingXZ

public final float headingXZ()
Computes the vector's direction in the XZ plane. The positive X axis equals 0 degrees.

Returns:
rotation angle

headingYZ

public final float headingYZ()
Computes the vector's direction in the YZ plane. The positive Z axis equals 0 degrees.

Returns:
rotation angle

interpolateTo

public final Vec3D interpolateTo(Vec3D v,
                                 float f)
Interpolates the vector towards the given target vector, using linear interpolation.

Parameters:
v - target vector
f - interpolation factor (should be in the range 0..1)
Returns:
result as new vector

interpolateTo

public Vec3D interpolateTo(Vec3D v,
                           float f,
                           InterpolateStrategy s)
Interpolates the vector towards the given target vector, using the given InterpolateStrategy.

Parameters:
v - target vector
f - interpolation factor (should be in the range 0..1)
s - InterpolateStrategy instance
Returns:
result as new vector

interpolateToSelf

public final Vec3D interpolateToSelf(Vec3D v,
                                     float f)
Interpolates the vector towards the given target vector, using linear interpolation.

Parameters:
v - target vector
f - interpolation factor (should be in the range 0..1)
Returns:
itself, result overrides current vector

interpolateToSelf

public Vec3D interpolateToSelf(Vec3D v,
                               float f,
                               InterpolateStrategy s)
Interpolates the vector towards the given target vector, using the given InterpolateStrategy.

Parameters:
v - target vector
f - interpolation factor (should be in the range 0..1)
s - InterpolateStrategy instance
Returns:
itself, result overrides current vector

invert

public final Vec3D invert()
Scales vector uniformly by factor -1 ( v = -v ), overrides coordinates with result.

Returns:
itself

isInAABB

public boolean isInAABB(AABB box)
Checks if the point is inside the given AABB.

Parameters:
box - bounding box to check
Returns:
true, if point is inside

isInAABB

public boolean isInAABB(Vec3D boxOrigin,
                        Vec3D boxExtent)
Checks if the point is inside the given axis-aligned bounding box.

Parameters:
boxOrigin - bounding box origin/center
boxExtent - bounding box extends (half measure)
Returns:
true, if point is inside the box

isZeroVector

public final boolean isZeroVector()
Checks if vector has a magnitude equals or close to zero.

Returns:
true, if zero vector

jitter

public final Vec3D jitter(float j)
Jitter.

Parameters:
j - the j
Returns:
the vec3 d

jitter

public final Vec3D jitter(float jx,
                          float jy,
                          float jz)
Adds random jitter to the vector.

Parameters:
jx - maximum x jitter
jy - maximum y jitter
jz - maximum z jitter
Returns:
itself

jitter

public final Vec3D jitter(Vec3D jitterVec)
Jitter.

Parameters:
jitterVec - the jitter vec
Returns:
the vec3 d

limit

public final Vec3D limit(float lim)
Limits the vector's magnitude to the length given.

Parameters:
lim - new maximum magnitude
Returns:
itself

magnitude

public float magnitude()
Calculates the magnitude/eucledian length of the vector.

Returns:
vector length

magSquared

public float magSquared()
Calculates only the squared magnitude/length of the vector. Useful for inverse square law applications and/or for speed reasons or if the real eucledian distance is not required (e.g. sorting).

Returns:
squared magnitude (x^2 + y^2 + z^2)

maxSelf

public final Vec3D maxSelf(Vec3D b)
Max self.

Parameters:
b - the b
Returns:
the vec3 d

minSelf

public final Vec3D minSelf(Vec3D b)
Min self.

Parameters:
b - the b
Returns:
the vec3 d

modSelf

public final Vec3D modSelf(float base)
Applies a uniform modulo operation to the vector, using the same base for all components.

Parameters:
base - the base
Returns:
itself

modSelf

public final Vec3D modSelf(float bx,
                           float by,
                           float bz)
Calculates modulo operation for each vector component separately.

Parameters:
bx - the bx
by - the by
bz - the bz
Returns:
itself

normalize

public Vec3D normalize()
Normalizes the vector so that its magnitude = 1.

Returns:
itself

normalizeTo

public Vec3D normalizeTo(float len)
Normalizes the vector to the given length.

Parameters:
len - desired length
Returns:
itself

reciprocal

public final Vec3D reciprocal()
Replaces the vector components with their multiplicative inverse.

Returns:
itself

rotateAroundAxis

public final Vec3D rotateAroundAxis(Vec3D axis,
                                    float theta)
Rotates the vector around the giving axis.

Parameters:
axis - rotation axis vector
theta - rotation angle (in radians)
Returns:
itself

rotateX

public final Vec3D rotateX(float theta)
Rotates the vector by the given angle around the X axis.

Parameters:
theta - the theta
Returns:
itself

rotateY

public final Vec3D rotateY(float theta)
Rotates the vector by the given angle around the Y axis.

Parameters:
theta - the theta
Returns:
itself

rotateZ

public final Vec3D rotateZ(float theta)
Rotates the vector by the given angle around the Z axis.

Parameters:
theta - the theta
Returns:
itself

scale

public Vec3D scale(float s)
Scales vector uniformly and returns result as new vector.

Parameters:
s - scale factor
Returns:
new vector

scale

public Vec3D scale(float a,
                   float b,
                   float c)
Scales vector non-uniformly and returns result as new vector.

Parameters:
a - scale factor for X coordinate
b - scale factor for Y coordinate
c - scale factor for Z coordinate
Returns:
new vector

scale

public Vec3D scale(Vec3D s)
Scales vector non-uniformly by vector v and returns result as new vector.

Parameters:
s - scale vector
Returns:
new vector

scaleSelf

public Vec3D scaleSelf(float s)
Scales vector uniformly and overrides coordinates with result.

Parameters:
s - scale factor
Returns:
itself

scaleSelf

public Vec3D scaleSelf(float a,
                       float b,
                       float c)
Scales vector non-uniformly by vector {a,b,c} and overrides coordinates with result.

Parameters:
a - scale factor for X coordinate
b - scale factor for Y coordinate
c - scale factor for Z coordinate
Returns:
itself

scaleSelf

public Vec3D scaleSelf(Vec3D s)
Scales vector non-uniformly by vector v and overrides coordinates with result.

Parameters:
s - scale vector
Returns:
itself

set

public Vec3D set(float x,
                 float y,
                 float z)
Overrides coordinates with the given values.

Parameters:
x - the x
y - the y
z - the z
Returns:
itself

set

public Vec3D set(Vec3D v)
Overrides coordinates with the ones of the given vector.

Parameters:
v - vector to be copied
Returns:
itself

setComponent

public Vec3D setComponent(Vec3D.Axis id,
                          float val)

setXY

public Vec3D setXY(Vec2D v)
Overrides XY coordinates with the ones of the given 2D vector.

Parameters:
v - 2D vector
Returns:
itself

signum

public Vec3D signum()
Replaces all vector components with the signum of their original values. In other words if a components value was negative its new value will be -1, if zero => 0, if positive => +1

Returns:
itself

sub

public final Vec3D sub(float a,
                       float b,
                       float c)
Subtracts vector {a,b,c} and returns result as new vector.

Parameters:
a - X coordinate
b - Y coordinate
c - Z coordinate
Returns:
result as new vector

sub

public final Vec3D sub(Vec3D v)
Subtracts vector v and returns result as new vector.

Parameters:
v - vector to be subtracted
Returns:
result as new vector

subSelf

public final Vec3D subSelf(float a,
                           float b,
                           float c)
Subtracts vector {a,b,c} and overrides coordinates with result.

Parameters:
a - X coordinate
b - Y coordinate
c - Z coordinate
Returns:
itself

subSelf

public final Vec3D subSelf(Vec3D v)
Subtracts vector v and overrides coordinates with result.

Parameters:
v - vector to be subtracted
Returns:
itself

to2DXY

public final Vec2D to2DXY()
Creates a new 2D vector of the XY components.

Returns:
new vector

to2DXZ

public final Vec2D to2DXZ()
Creates a new 2D vector of the XZ components.

Returns:
new vector

to2DYZ

public final Vec2D to2DYZ()
Creates a new 2D vector of the YZ components.

Returns:
new vector

toArray

public float[] toArray()

toCartesian

public Vec3D toCartesian()
Converts the spherical vector back into cartesian coordinates.

Returns:
itself

toSpherical

public Vec3D toSpherical()
Converts the vector into spherical coordinates. After the conversion the vector components are to be interpreted as:

Returns:
itself

toString

public java.lang.String toString()
Overrides:
toString in class java.lang.Object