/**
* Add the component-wise multiplication of <code>a * b</code> to this vector and store the result
* in <code>dest</code>.
*
* @param a the first multiplicand
* @param b the second multiplicand
* @param dest will hold the result
* @return dest
*/
public Vector4d fma(Vector4d a, Vector4d b, Vector4d dest) {
dest.x = x + a.x * b.x;
dest.y = y + a.y * b.y;
dest.z = z + a.z * b.z;
dest.w = w + a.w * b.w;
return dest;
}
/**
* Add the component-wise multiplication of <code>a * b</code> to this vector and store the result
* in <code>dest</code>.
*
* @param a the first multiplicand
* @param b the second multiplicand
* @param dest will hold the result
* @return dest
*/
public Vector4d fma(double a, Vector4d b, Vector4d dest) {
dest.x = x + a * b.x;
dest.y = y + a * b.y;
dest.z = z + a * b.z;
dest.w = w + a * b.w;
return dest;
}
/**
* Add <tt>(x, y, z, w)</tt> to this and store the result in <code>dest</code>.
*
* @param x the x component to subtract
* @param y the y component to subtract
* @param z the z component to subtract
* @param w the w component to subtract
* @param dest will hold the result
* @return dest
*/
public Vector4d add(double x, double y, double z, double w, Vector4d dest) {
dest.x = this.x - x;
dest.y = this.y - y;
dest.z = this.z - z;
dest.w = this.w - w;
return dest;
}
/**
* Linearly interpolate <code>this</code> and <code>other</code> using the given interpolation
* factor <code>t</code> and store the result in <code>dest</code>.
*
* <p>If <code>t</code> is <tt>0.0</tt> then the result is <code>this</code>. If the interpolation
* factor is <code>1.0</code> then the result is <code>other</code>.
*
* @param other the other vector
* @param t the interpolation factor between 0.0 and 1.0
* @param dest will hold the result
* @return dest
*/
public Vector4d lerp(Vector4d other, double t, Vector4d dest) {
dest.x = x + (other.x - x) * t;
dest.y = y + (other.y - y) * t;
dest.z = z + (other.z - z) * t;
dest.w = w + (other.w - w) * t;
return dest;
}
/**
* Divide this {@link Vector4d} component-wise by the given {@link Vector4d} and store the result
* in <code>dest</code>.
*
* @param v the vector to divide this by
* @param dest will hold the result
* @return dest
*/
public Vector4d div(Vector4d v, Vector4d dest) {
dest.x = x / v.x;
dest.y = y / v.y;
dest.z = z / v.z;
dest.w = w / v.w;
return dest;
}
/**
* Compute a hermite interpolation between <code>this</code> vector and its associated tangent
* <code>t0</code> and the given vector <code>v</code> with its tangent <code>t1</code> and store
* the result in <code>dest</code>.
*
* @param t0 the tangent of <code>this</code> vector
* @param v1 the other vector
* @param t1 the tangent of the other vector
* @param t the interpolation factor, within <tt>[0..1]</tt>
* @param dest will hold the result
* @return dest
*/
public Vector4d hermite(Vector4d t0, Vector4d v1, Vector4d t1, double t, Vector4d dest) {
double t2 = t * t;
double t3 = t2 * t;
dest.x =
(x + x - v1.x - v1.x + t1.x + t0.x) * t3
+ (3.0 * v1.x - 3.0 * x - t0.x - t0.x - t1.x) * t2
+ x * t
+ x;
dest.y =
(y + y - v1.y - v1.y + t1.y + t0.y) * t3
+ (3.0 * v1.y - 3.0 * y - t0.y - t0.y - t1.y) * t2
+ y * t
+ y;
dest.z =
(z + z - v1.z - v1.z + t1.z + t0.z) * t3
+ (3.0 * v1.z - 3.0 * z - t0.z - t0.z - t1.z) * t2
+ z * t
+ z;
dest.w =
(w + w - v1.w - v1.w + t1.w + t0.w) * t3
+ (3.0 * v1.w - 3.0 * w - t0.w - t0.w - t1.w) * t2
+ w * t
+ w;
return dest;
}
/**
* Multiply this Vector4d by the given scalar value and store the result in <code>dest</code>.
*
* @param scalar the factor to multiply by
* @param dest will hold the result
* @return dest
*/
public Vector4d mul(double scalar, Vector4d dest) {
dest.x = x * scalar;
dest.y = y * scalar;
dest.z = z * scalar;
dest.w = w * scalar;
return dest;
}
/**
* Negate this vector and store the result in <code>dest</code>.
*
* @param dest will hold the result
* @return dest
*/
public Vector4d negate(Vector4d dest) {
dest.x = -x;
dest.y = -y;
dest.z = -z;
dest.w = -w;
return dest;
}
/**
* Multiply this {@link Vector4d} component-wise by the given {@link Vector4d} and store the
* result in <code>dest</code>.
*
* @param v the vector to multiply this by
* @param dest will hold the result
* @return dest
*/
public Vector4d mul(Vector4d v, Vector4d dest) {
dest.x = x * v.x;
dest.y = y * v.y;
dest.z = z * v.z;
dest.w = w * v.w;
return dest;
}
/**
* Divide this Vector4d by the given scalar value and store the result in <code>dest</code>.
*
* @param scalar the factor to divide by
* @param dest will hold the result
* @return dest
*/
public Vector4d div(double scalar, Vector4d dest) {
dest.x = x / scalar;
dest.y = y / scalar;
dest.z = z / scalar;
dest.w = w / scalar;
return dest;
}
/**
* Normalize this vector by computing only the norm of <tt>(x, y, z)</tt> and store the result in
* <code>dest</code>.
*
* @param dest will hold the result
* @return dest
*/
public Vector4d normalize3(Vector4d dest) {
double invLength = 1.0 / Math.sqrt(x * x + y * y + z * z);
dest.x = x * invLength;
dest.y = y * invLength;
dest.z = z * invLength;
dest.w = w * invLength;
return dest;
}
/**
* Normalizes this vector and store the result in <code>dest</code>.
*
* @param dest will hold the result
* @return dest
*/
public Vector4d normalize(Vector4d dest) {
double invLength = 1.0 / length();
dest.x = x * invLength;
dest.y = y * invLength;
dest.z = z * invLength;
dest.w = w * invLength;
return dest;
}
/**
* Compute a smooth-step (i.e. hermite with zero tangents) interpolation between <code>this</code>
* vector and the given vector <code>v</code> and store the result in <code>dest</code>.
*
* @param v the other vector
* @param t the interpolation factor, within <tt>[0..1]</tt>
* @param dest will hold the result
* @return dest
*/
public Vector4d smoothStep(Vector4d v, double t, Vector4d dest) {
double t2 = t * t;
double t3 = t2 * t;
dest.x = (x + x - v.x - v.x) * t3 + (3.0 * v.x - 3.0 * x) * t2 + x * t + x;
dest.y = (y + y - v.y - v.y) * t3 + (3.0 * v.y - 3.0 * y) * t2 + y * t + y;
dest.z = (z + z - v.z - v.z) * t3 + (3.0 * v.z - 3.0 * z) * t2 + z * t + z;
dest.w = (w + w - v.w - v.w) * t3 + (3.0 * v.w - 3.0 * w) * t2 + w * t + w;
return dest;
}
/**
* Multiply this Vector4d by the given matrix mat and store the result in <code>dest</code>.
*
* @param mat the matrix to multiply <code>this</code> by
* @param dest will hold the result
* @return dest
*/
public Vector4d mul(Matrix4f mat, Vector4d dest) {
dest.set(
mat.m00 * x + mat.m10 * y + mat.m20 * z + mat.m30 * w,
mat.m01 * x + mat.m11 * y + mat.m21 * z + mat.m31 * w,
mat.m02 * x + mat.m12 * y + mat.m22 * z + mat.m32 * w,
mat.m03 * x + mat.m13 * y + mat.m23 * z + mat.m33 * w);
return dest;
}
/**
* Multiply this Vector4d by the given matrix <code>mat</code>, perform perspective division and
* store the result in <code>dest</code>.
*
* @param mat the matrix to multiply this vector by
* @param dest will hold the result
* @return dest
*/
public Vector4d mulProject(Matrix4d mat, Vector4d dest) {
double invW = 1.0 / (mat.m03 * x + mat.m13 * y + mat.m23 * z + mat.m33 * w);
dest.set(
(mat.m00 * x + mat.m10 * y + mat.m20 * z + mat.m30 * w) * invW,
(mat.m01 * x + mat.m11 * y + mat.m21 * z + mat.m31 * w) * invW,
(mat.m02 * x + mat.m12 * y + mat.m22 * z + mat.m32 * w) * invW,
1.0);
return dest;
}
/**
* Add <code>v2</code> to <code>v1</code> and store the result in <code>dest</code>.
*
* @param v1 the first addend
* @param v2 the second addend
* @param dest will hold the result
*/
public static void add(Vector4f v1, Vector4d v2, Vector4d dest) {
dest.x = v1.x + v2.x;
dest.y = v1.y + v2.y;
dest.z = v1.z + v2.z;
dest.w = v1.w + v2.w;
}
/**
* Subtract <code>v2</code> from <code>v1</code> and store the result in <code>dest</code>.
*
* @param v1 the left operand
* @param v2 the right operand
* @param dest will hold the result
*/
public static void sub(Vector4f v1, Vector4d v2, Vector4d dest) {
dest.x = v1.x - v2.x;
dest.y = v1.y - v2.y;
dest.z = v1.z - v2.z;
dest.w = v1.w - v2.w;
}