eessppeelllloo/processing4
1
0
Fork 0
mirror of https://github.com/processing/processing4.git synced 2026-02-13 18:35:37 +01:00
Code Issues Packages Projects Releases Wiki Activity

remove setX/Y/Z, add div/mult on vectors, remove get()

Browse Source
This commit is contained in:
benfry
2008-10-21 23:06:59 +00:00
parent 6598a85b80
commit d86be6fe9d
1 changed files with 167 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

298
core/src/processing/core/PVector.java
View File

@@ -25,41 +25,41 @@
package processing.core;
/**
* A class to describe a two or three dimensional vector. When
* A class to describe a two or three dimensional vector.
* <p>
* The result of all functions are applied to the vector itself, with the
* The result of all functions are applied to the vector itself, with the
* exception of cross(), which returns a new PVector (or writes to a specified
* 'target' PVector). That is, add() will add the contents of one vector to
* this one. Using add() with additional parameters allows you to put the
* result into a new PVector. Functions that act on multiple vectors also
* 'target' PVector). That is, add() will add the contents of one vector to
* this one. Using add() with additional parameters allows you to put the
* result into a new PVector. Functions that act on multiple vectors also
* include static versions. Because creating new objects can be computationally
* expensive, most functions include an optional 'target' PVector, so that a
* expensive, most functions include an optional 'target' PVector, so that a
* new PVector object is not created with each operation.
* <p>
* Initially based on the Vector3D class by <a href="http://www.shiffman.net">Dan Shiffman</a>.
*/
public class PVector {
/** The x component of the vector. */
public float x;
/** The y component of the vector. */
public float y;
/** The z component of the vector. */
public float z;
/** Array so that this can be temporarily used in an array context */
protected float[] array;
/**
* Constructor for an empty vector: x, y, and z are set to 0.
*/
public PVector() {
}
/**
* Constructor for a 3D vector.
*
@@ -73,7 +73,7 @@ public class PVector {
this.z = z;
}
/**
* Constructor for a 2D vector: z coordinate is set to 0.
*
@@ -85,40 +85,11 @@ public class PVector {
this.y = y;
this.z = 0;
}
/**
* Set the x coordinate.
*
* @param x the x coordinate.
*/
public void setX(float x) {
this.x = x;
}
/**
* Set the y coordinate.
*
* @param y the y coordinate.
*/
public void setY(float y) {
this.y = y;
}
/**
* Set the z coordinate.
*
* @param z the z coordinate.
*/
public void setZ(float z) {
this.z = z;
}
/**
* Set x, y, and z coordinates.
*
*
* @param x the x coordinate.
* @param y the y coordinate.
* @param z the z coordinate.
@@ -129,7 +100,7 @@ public class PVector {
this.z = z;
}
/**
* Set x, y, and z coordinates from a Vector3D object.
*
@@ -140,10 +111,10 @@ public class PVector {
y = v.y;
z = v.z;
}
/**
* Set the x, y (and maybe z) coordinates using a float[] array as the source.
* Set the x, y (and maybe z) coordinates using a float[] array as the source.
* @param source array to copy from
*/
public void set(float[] source) {
@@ -155,8 +126,8 @@ public class PVector {
z = source[2];
}
}
/**
* Get a copy of this vector.
* @return
@@ -164,40 +135,31 @@ public class PVector {
public PVector get() {
return new PVector(x, y, z);
}
/**
*
*
* @param target
* @return
*/
public float[] get(float[] target) {
if (target == null) {
return new float[] { x, y, z };
return new float[] { x, y, z };
}
if (target.length >= 2) {
target[0] = x;
target[1] = y;
}
}
if (target.length >= 3) {
target[2] = z;
}
return target;
}
/**
* Copy the vector (synonym for get()).
* @return a copy of the vector
*/
public PVector copy() {
return new PVector(x, y, z);
}
/**
* Calculate the magnitude (length) of the vector
* @return the magnitude of the vector
* @return the magnitude of the vector
*/
public float mag() {
return (float) Math.sqrt(x*x + y*y + z*z);
@@ -206,40 +168,40 @@ public class PVector {
/**
* Add a vector to this vector
* @param v the vector to be added
* @param v the vector to be added
*/
public void add(PVector v) {
x += v.x;
y += v.y;
z += v.z;
}
public void add(float x, float y, float z) {
this.x += x;
this.y += y;
this.z += z;
}
/**
* Add two vectors
* @param v1 a vector
* @param v2 another vector
* @return a new vector that is the sum of v1 and v2
*/
* @param v2 another vector
* @return a new vector that is the sum of v1 and v2
*/
static public PVector add(PVector v1, PVector v2) {
return add(v1, v2, null);
}
/**
* Add two vectors into a target vector
* @param v1 a vector
* @param v2 another vector
* @param target the target vector (if null, a new vector will be created)
* @return a new vector that is the sum of v1 and v2
*/
* @return a new vector that is the sum of v1 and v2
*/
static public PVector add(PVector v1, PVector v2, PVector target) {
if (target == null) {
target = new PVector(v1.x + v2.x,v1.y + v2.y, v1.z + v2.z);
@@ -248,37 +210,37 @@ public class PVector {
}
return target;
}
/**
* Subtract a vector from this vector
* @param v the vector to be subtracted
*/
* @param v the vector to be subtracted
*/
public void sub(PVector v) {
x -= v.x;
y -= v.y;
z -= v.z;
}
public void sub(float x, float y, float z) {
this.x -= x;
this.y -= y;
this.z -= z;
}
/**
* Subtract one vector from another
* @param v1 a vector
* @param v2 another vector
* @return a new vector that is v1 - v2
*/
* @param v2 another vector
* @return a new vector that is v1 - v2
*/
static public PVector sub(PVector v1, PVector v2) {
return sub(v1, v2, null);
}
static public PVector sub(PVector v1, PVector v2, PVector target) {
if (target == null) {
target = new PVector(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
@@ -291,8 +253,8 @@ public class PVector {
/**
* Multiply this vector by a scalar
* @param n the value to multiply by
*/
* @param n the value to multiply by
*/
public void mult(float n) {
x *= n;
y *= n;
@@ -303,21 +265,21 @@ public class PVector {
/**
* Multiply a vector by a scalar
* @param v a vector
* @param n scalar
* @param n scalar
* @return a new vector that is v1 * n
*/
*/
static public PVector mult(PVector v, float n) {
return mult(v, n, null);
}
/**
* Multiply a vector by a scalar, and write the result into a target PVector.
* @param v a vector
* @param n scalar
* @param n scalar
* @param target PVector to store the result
* @return the target vector, now set to v1 * n
*/
*/
static public PVector mult(PVector v, float n, PVector target) {
if (target == null) {
target = new PVector(v.x*n, v.y*n, v.z*n);
@@ -327,29 +289,66 @@ public class PVector {
return target;
}
/**
* Multiply each element of one vector by the elements of another vector.
* @param n the value to multiply by
*/
public void mult(PVector v) {
x *= v.x;
y *= v.y;
z *= v.z;
}
/**
* Multiply each element of one vector by the individual elements of another
* vector, and return the result as a new PVector.
*/
static public PVector mult(PVector v1, PVector v2) {
return mult(v1, v2, null);
}
/**
* Multiply each element of one vector by the individual elements of another
* vector, and write the result into a target vector.
* @param v1 the first vector
* @param v2 the second vector
* @param target PVector to store the result
*/
static public PVector mult(PVector v1, PVector v2, PVector target) {
if (target == null) {
target = new PVector(v1.x*v2.x, v1.y*v2.y, v1.z*v2.z);
} else {
target.set(v1.x*v2.x, v1.y*v2.y, v1.z*v2.z);
}
return target;
}
/**
* Divide this vector by a scalar
* @param n the value to divide by
*/
* @param n the value to divide by
*/
public void div(float n) {
x /= n;
y /= n;
z /= n;
}
/**
* Divide a vector by a scalar and return the result in a new vector.
* @param v a vector
* @param n scalar
* @param n scalar
* @return a new vector that is v1 / n
*/
static public PVector div(PVector v, float n) {
return div(v, n, null);
}
static public PVector div(PVector v, float n, PVector target) {
if (target == null) {
target = new PVector(v.x/n, v.y/n, v.z/n);
@@ -360,10 +359,46 @@ public class PVector {
}
/**
* Divide each element of one vector by the elements of another vector.
*/
public void div(PVector v) {
x /= v.x;
y /= v.y;
z /= v.z;
}
/**
* Multiply each element of one vector by the individual elements of another
* vector, and return the result as a new PVector.
*/
static public PVector div(PVector v1, PVector v2) {
return div(v1, v2, null);
}
/**
* Divide each element of one vector by the individual elements of another
* vector, and write the result into a target vector.
* @param v1 the first vector
* @param v2 the second vector
* @param target PVector to store the result
*/
static public PVector div(PVector v1, PVector v2, PVector target) {
if (target == null) {
target = new PVector(v1.x/v2.x, v1.y/v2.y, v1.z/v2.z);
} else {
target.set(v1.x/v2.x, v1.y/v2.y, v1.z/v2.z);
}
return target;
}
/**
* Calculate the Euclidean distance between two points (considering a point as a vector object)
* @param v another vector
* @return the Euclidean distance between
* @return the Euclidean distance between
*/
public float dist(PVector v) {
float dx = x - v.x;
@@ -372,7 +407,7 @@ public class PVector {
return (float) Math.sqrt(dx*dx + dy*dy + dz*dz);
}
/**
* Calculate the Euclidean distance between two points (considering a point as a vector object)
* @param v1 a vector
@@ -386,38 +421,38 @@ public class PVector {
return (float) Math.sqrt(dx*dx + dy*dy + dz*dz);
}
/**
* Calculate the dot product with another vector
* @return the dot product
*/
*/
public float dot(PVector v) {
return x*v.x + y*v.y + z*v.z;
}
public float dot(float x, float y, float z) {
return this.x*x + this.y*y + this.z*z;
}
/**
* Return a vector composed of the cross product between this and another.
*/
public PVector cross(PVector v) {
return cross(v, null);
}
/**
* Perform cross product between this and another vector, and store the
* Perform cross product between this and another vector, and store the
* result in 'target'. If target is null, a new vector is created.
*/
public PVector cross(PVector v, PVector target) {
float crossX = y * v.z - v.y * z;
float crossY = z * v.x - v.z * x;
float crossZ = x * v.y - v.x * y;
if (target == null) {
target = new PVector(crossX, crossY, crossZ);
} else {
@@ -425,8 +460,8 @@ public class PVector {
}
return target;
}
static public PVector cross(PVector v1, PVector v2, PVector target) {
float crossX = v1.y * v2.z - v2.y * v1.z;
float crossY = v1.z * v2.x - v2.z * v1.x;
@@ -450,10 +485,10 @@ public class PVector {
div(m);
}
}
/**
* Normalize this vector, storing the result in another vector.
* Normalize this vector, storing the result in another vector.
* @param target Set to null to create a new vector
* @return a new vector (if target was null), or target
*/
@@ -470,7 +505,7 @@ public class PVector {
return target;
}
/**
* Limit the magnitude of this vector
* @param max the maximum length to limit this vector
@@ -482,38 +517,39 @@ public class PVector {
}
}
/**
* Calculate the angle of rotation for this vector (only 2D vectors)
* @return the angle of rotation
*/
*/
public float heading2D() {
float angle = (float) Math.atan2(-y, x);
return -1*angle;
}
/**
* Calculate the angle between two vectors, using the dot product
* @param v1 a vector
* @param v2 another vector
* @return the angle between the vectors
*/
*/
static public float angleBetween(PVector v1, PVector v2) {
float dot = v1.dot(v2);
float theta = (float) Math.acos(dot / (v1.mag() * v2.mag()));
return theta;
}
public String toString() {
return "[ " + x + ", " + y + ", " + z + " ]";
}
/**
* Return a representation of this vector as an array. This is only for
* temporary use. If used in any other fashion, the contents should be copied.
/**
* Return a representation of this vector as a float array. This is only for
* temporary use. If used in any other fashion, the contents should be copied
* by using the get() command to copy into your own array.
*/
public float[] array() {
if (array == null) {