The Math script provides Vec3, Mat4 and Quat classes to manage three dimensional vectors, four by four matrices and quaternions respectively.
One very interesting thing to point about the Math script is that all Vec3, Mat4 and Quat methods are generics. This means that all
instance methods of Vec3, Mat4, and Quat can also be accessed as static methods in which the first parameter of the static method is the receiver.
The receiver does not have to be an instance of the class but can instead be a Vec3-like, Mat4-like or Quat-like object.
This means that a simple array (i.e []) can be used as the receiver for these methods.
Although the syntax section for each method will include the generic and non-generic one, the arguments for each method will be described as with the instance method syntax.
All methods that do not return something in particular in the math package are chainable.
Say you want to add two Vec3 vectors, v1 and v2. Then there are three ways of performing this operation:
v1.add(v2) Returns a new instance with the result of adding v1 and v2. This operation does not modify v1 or v2.v1.$add(v2) Returns the result of adding v1 to v2, but it alters v1 updating it with the result.vResult.add2(v1, v2) Stores the result of adding v1 to v2 in vResult, another Vec3 instance.These are the conventions we will be using for method naming. Methods altering the receiver will have a dollar sign (i.e. $), as opposed to
methods creating a new instance with the result. Methods requiring a receiver and the instances involved in the operation as formal parameters
will be suffixed with the number 2.
All classes extend from Array or some
DataView class (i.e. some typed array). This means that Vec3, Mat4
and Quat-like objects are plain arrays and not plain objects. Getters
have been added for all properties in Vec3, Mat4 and Quat
classes so you can still access them via vec.x, etc, but remember
that the inner implementation is an array, so vec3[0] will also
work.
A class to handle three dimensional vectors.
Create a new Vec3 instance from the x, y, z coordinates of a Quat.
Vec3.fromQuat(q);
Quat instance.Create a vector from a Quaternion.
var q = new Quat(1, 2, 3, 4),
v = Vec3.fromQuat(q); //Vec3(1, 2, 3)Creates a new Vec3 instance.
var v = new Vec3(x, y, z);
Create a (0, 0, 0) vector.
var v = new Vec3();Create a (1, 2, 3) vector.
var v = new Vec3(1, 2, 3);Set x, y, z coordinates of one Vec3 into another Vec3.
v1.setVec3(v2);
Vec3.setVec3(v1, v2);
Vec3 instance.Create two vectors and assign one vectors components to the other one.
var v1 = new Vec3(1, 2, 3),
v2 = new Vec3(4, 5, 6);
v1.setVec3(v2); //v1 now contains (x=4, y=5, z=6)Set an object’s x, y, z components to another object.
var v1 = [],
v2 = [ 4, 5, 6 ];
Vec3.setVec3(v1, v2); //v1 now has [4, 5, 6]Set x, y, z coordinates.
v1.set(x, y, z);
Vec3.set(v1, x, y, z);
Create two vectors and assign one vectors components to the other one.
var v1 = new Vec3(1, 2, 3),
v2 = new Vec3(4, 5, 6);
v1.set(v2.x, v2.y, v2.z); //v1 now contains (x=4, y=5, z=6)Set an object’s x, y, z components to another object.
var v1 = [],
v2 = [ 4, 5, 6 ];
Vec3.set(v1, v2.x, v2.y, v2.z); //v1 now has [4, 5, 6]Adds the x, y, z components of two Vec3 objects. Creates a new Vec3 instance and does not modify the original objects.
v1.add(v2);
Vec3.add(v1, v2);
Vec3 instance.Create two vectors and add them.
var v1 = new Vec3(1, 2, 3),
v2 = new Vec3(4, 5, 6);
v1.add(v2); //v1 and v2 are still the same but a new Vec3(5, 7, 9) was created.Create two x, y, z objects and add them.
var v1 = [ 1, 2, 3 ],
v2 = [ 4, 5, 6 ];
Vec3.add(v1, v2); //v1 and v2 are still the same but a new Vec3(5, 7, 9) was created.Adds the x, y, z components of two Vec3 objects. Modifies the original object.
v1.$add(v2);
Vec3.$add(v1, v2);
Vec3 instance.Create two vectors and add them.
var v1 = new Vec3(1, 2, 3),
v2 = new Vec3(4, 5, 6);
v1.$add(v2); //v1 is now Vec3(5, 7, 9).Create two x, y, z objects and add them.
var v1 = [ 1, 2, 3 ],
v2 = [ 4, 5, 6 ];
Vec3.$add(v1, v2); //v1 is now [ 5, 7, 9 ].Adds the x, y, z components of two Vec3 objects and stores the result in the receiver.
v1.add2(v2, v3);
Vec3.add2(v1, v2, v3);
Vec3 instance.Vec3 instance.Create two vectors and add them.
var v1 = new Vec3(),
v2 = new Vec3(1, 2, 3),
v3 = new Vec3(4, 5, 6);
v1.add2(v2, v3); //v1 is now Vec3(5, 7, 9), v2 and v3 are unchanged.Create two x, y, z objects and add them.
var v1 = [],
v2 = [ 1, 2, 3 ],
v3 = [ 4, 5, 6 ];
Vec3.add2(v1, v2, v3); //v2 and v3 are still the same but v1 is [ 5, 7, 9 ].Substracts the x, y, z components of two Vec3 objects. Creates a new Vec3 instance and does not modify the original objects.
v1.sub(v2);
Vec3.sub(v1, v2);
Vec3 instance.Create two vectors and substract them.
var v1 = new Vec3(1, 2, 3),
v2 = new Vec3(4, 5, 6);
v1.sub(v2); //v1 and v2 are still the same but a new Vec3(-3, -3, -3) was created.Create two x, y, z objects and substract them.
var v1 = [ 1, 2, 3 ],
v2 = [ 4, 5, 6 ];
Vec3.sub(v1, v2); //v1 and v2 are still the same but a new Vec3(-3, -3, -3) was created.Substracts the x, y, z components of two Vec3 objects. Modifies the original object.
v1.$sub(v2);
Vec3.$sub(v1, v2);
Vec3 instance.Create two vectors and substract them.
var v1 = new Vec3(1, 2, 3),
v2 = new Vec3(4, 5, 6);
v1.$sub(v2); //v1 is now Vec3(-3, -3, -3).Create two x, y, z objects and add them.
var v1 = [ 1, 2, 3 ],
v2 = [ 4, 5, 6 ];
Vec3.$sub(v1, v2); //v1 is now [ -3, -3, -3 ].Substracts the x, y, z components of two Vec3 objects and stores the result in the receiver.
v1.sub2(v2, v3);
Vec3.sub2(v1, v2, v3);
Vec3 instance.Vec3 instance.Create two vectors and substract them.
var v1 = new Vec3(),
v2 = new Vec3(1, 2, 3),
v3 = new Vec3(4, 5, 6);
v1.sub2(v2, v3); //v1 is now Vec3(-3, -3, -3), v2 and v3 are unchanged.Create two x, y, z objects and substract them.
var v1 = [],
v2 = [ 1, 2, 3 ],
v3 = [ 4, 5, 6 ];
Vec3.sub2(v1, v2, v3); //v2 and v3 are still the same but v1 is { x: -3, y: -3, z: -3 }.Scales the Vec3 vector by a real number. Creates a new Vec3 with the scaled components.
v1.scale(s);
Vec3.scale(v1, s);
Create a vector and scale it by 2.
var v1 = new Vec3(1, 2, 3);
v1.scale(2); //v1 is unchanged but a new Vec3(2, 4, 6) is created.Create an x, y, z object and scale it by 2.
var v1 = [ 1, 2, 3 ];
Vec3.scale(v1, 2); //v1 is still the same but a new Vec3(2, 4, 6) was created.Scales the Vec3 vector by a real number. Changes the original object.
v1.$scale(s);
Vec3.$scale(v1, s);
Create a vector and scale it by 2.
var v1 = new Vec3(1, 2, 3);
v1.$scale(2); //v1 is now Vec3(2, 4, 6).Create an x, y, z object and scale it by 2.
var v1 = [ 1, 2, 3 ];
Vec3.$scale(v1, 2); //v1 is now [ 2, 4, 6 ].Negates a Vec3. Returns a new instance.
v1.neg();
Vec3.neg(v1);
Create a vector and negate it.
var v1 = new Vec3(1, 2, 3);
v1.neg(); //v1 is unchanged but a new Vec3(-1, -2, -3) is created.Create an x, y, z object and negate it.
var v1 = [ 1, 2, 3 ];
Vec3.neg(v1); //v1 is still the same but a new Vec3(-1, -2, -3).Negates a Vec3. Changes the original object.
v1.$neg();
Vec3.$neg(v1);
Create a vector and negate it.
var v1 = new Vec3(1, 2, 3);
v1.$neg(); //v1 is now Vec3(-1, -2, -3).Create an x, y, z object and negate it.
var v1 = [ 1, 2, 3 ];
Vec3.neg(v1); //v1 is now [ -1, -2, -3 ].Creates a unit vector from the coordinates of Vec3.
v1.unit();
Vec3.unit(v1);
Create a vector and make a unit vector from it.
var v1 = new Vec3(1, 2, 3);
v1.unit(); //v1 is unchanged but a new unit vector Vec3 is created.Create an x, y, z object and make a unit vector from it.
var v1 = [ 1, 2, 3 ];
Vec3.unit(v1); //v1 is still the same but a new Vec3 that is a unit vector is created.Creates a unit vector from the Vec3 coordinates. Changes the original object.
v1.$unit();
Vec3.$unit(v1);
Create a vector and make a unit vector from it.
var v1 = new Vec3(1, 2, 3);
v1.$unit(); //v1 is now a unit vector.Create an x, y, z object make a unit vector from it.
var v1 = [ 1, 2, 3 ];
Vec3.$unit(v1); //v1 is now a unit vector object.Makes a cross product of two Vec3 instances. Creates a new Vec3 and does not modify the original objects.
You can find more information about the cross product here.
v1.cross(v2);
Vec3.cross(v1, v2);
Vec3 instance.Create two vectors and make a cross product.
var v1 = new Vec3(1, 2, 3),
v2 = new Vec3(4, 5, 6);
v1.cross(v2); //v1 and v2 are still the same but a new Vec3 was created with the result.Create two x, y, z objects and make a cross product.
var v1 = [ 1, 2, 3 ],
v2 = [ 4, 5, 6 ];
//v1 and v2 are still the same but a new Vec3 with the result was created.
var ans = Vec3.cross(v1, v2);Makes a cross product of two Vec3 instances. Modifies the original object.
You can find more information about the cross product here.
v1.$cross(v2);
Vec3.$cross(v1, v2);
Vec3 instance.Create two vectors and make a cross product.
var v1 = new Vec3(1, 2, 3),
v2 = new Vec3(4, 5, 6);
v1.$cross(v2); //v1 contains now the result.Create two x, y, z objects and make a cross product.
var v1 = [ 1, 2, 3 ],
v2 = [ 4, 5, 6 ];
//v1 contains now the result.
var ans = Vec3.$cross(v1, v2);Calculates the distance between two Vec3.
v1.distTo(v2);
Vec3.distTo(v1, v2);
Vec3 instance.Create two vectors and calculate the distance.
var v1 = new Vec3(1, 2, 3),
v2 = new Vec3(4, 5, 6);
v1.distTo(v2); //a real value with the distance is returned.Create two x, y, z objects and calculate their distance.
var v1 = [ 1, 2, 3 ],
v2 = [ 4, 5, 6 ];
//a real number with the distance is returned.
var ans = Vec3.distTo(v1, v2);Calculates the squared distance between two Vec3.
v1.distToSq(v2);
Vec3.distToSq(v1, v2);
Vec3 instance.Create two vectors and calculate the squared distance.
var v1 = new Vec3(1, 2, 3),
v2 = new Vec3(4, 5, 6);
v1.distToSq(v2); //a real value with the squared distance is returned.Create two x, y, z objects and calculate their squared distance.
var v1 = [ 1, 2, 3 ],
v2 = [ 4, 5, 6 ];
//a real number with the squared distance is returned.
var ans = Vec3.distToSq(v1, v2);Calculates the norm of Vec3.
v1.norm();
Vec3.norm(v1);
Create a vector and calculate its norm.
var v1 = new Vec3(1, 2, 3);
vi.norm(); //returns the real valued norm.Create an x, y, z object and calculate its norm.
var v1 = [ 1, 2, 3 ];
//A real number with the norm is returned.
var ans = Vec3.norm(v1);Calculates the squared norm of Vec3.
v1.normSq();
Vec3.normSq(v1);
Create a vector and calculate its squared norm.
var v1 = new Vec3(1, 2, 3);
vi.normSq(); //returns the real valued norm.Create an x, y, z object and calculate its squared norm.
var v1 = [ 1, 2, 3 ];
//A real number with the squared norm is returned.
var ans = Vec3.normSq(v1);Calculates the dot product between two Vec3. You can find more information about the
dot product here.
v1.dot(v2);
Vec3.dot(v1, v2);
Vec3 instance.Create two vectors and calculate the dot product.
var v1 = new Vec3(1, 2, 3),
v2 = new Vec3(4, 5, 6);
v1.dot(v2); //a real value with the dot product is returned.Create two x, y, z objects and calculate the dot product.
var v1 = [ 1, 2, 3 ],
v2 = [ 4, 5, 6 ];
//a real number with the dot product is returned.
var ans = Vec3.dot(v1, v2);Clones a vector.
v1.clone();
Vec3.clone(v1);
A class to handle four by four matrices.
Create a new Mat4 instance from a Quat instance. The
Quaternion must be a unit quaternion.
Mat4.fromQuat(q);
Quat instance.Create a matrix from a Quaternion.
var q = new Quat(1, 2, 3, 4).$unit(),
m = Mat4.fromQuat(q); //a new Mat4 instanceCreates a new Mat4 instance. If no arguments are set then an Identity matrix is created.
var m = new Mat4();
var m = new Mat4(n11, n12, n13, n14,
n21, n22, n23, n24,
n31, n32, n33, n34,
n41, n42, n43, n44);
Create an identity matrix.
var m = new Mat4();Create a null matrix.
var m = new Mat4( 0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0 );Modifies the matrix to be an Identity matrix.
m.id();
Mat4.id(m);
Create an identity matrix from some random matrix.
var m = new Mat4( 1, 2, 3, 4,
1, 2, 3, 4,
1, 2, 3, 4,
1, 2, 3, 4 );
m.id(); //m is now the Identity matrix.Create an identity matrix object.
var m = [];
Mat4.id(m); //m object components are the Identity matrix ones.Set all matrix coordinates.
m.set(n11, n12, n13, n14,
n21, n22, n23, n24,
n31, n32, n33, n34,
n41, n42, n43, n44);
Mat4.set(m, n11, n12, n13, n14,
n21, n22, n23, n24,
n31, n32, n33, n34,
n41, n42, n43, n44);
Create a matrix and set some values to it.
var m = new Mat4();
m.set(1, 2, 3, 4,
1, 2, 3, 4,
1, 2, 3, 4,
1, 2, 3, 4);Set an empty object matrix coordinates onto some values.
var m = [];
Mat4.set(m, 1, 2, 3, 4,
1, 2, 3, 4,
1, 2, 3, 4,
1, 2, 3, 4);Multiplies a Mat4 by a Vec3. Returns a new Vec3 without modifying the passed in object.
m.mulVec3(v);
Mat4.mulVec3(m, v);
Vec3 instance.Create a matrix and a vector and multiply them.
var m = new Mat4(),
v = new Vec3(1, 1, 1);
m.mulVec3(v);Create a matrix object and a vector object and multiply them.
var m = [],
v = [];
Mat4.id(m);
Vec3.set(v, 1, 1, 1);
Mat4.mulVec3(m, v);Multiplies a Mat4 by a Vec3. Modifies the receiver.
m.$mulVec3(v);
Mat4.$mulVec3(m, v);
Vec3 instance.Create a matrix and a vector and multiply them.
var m = new Mat4(),
v = new Vec3(1, 1, 1);
m.$mulVec3(v);Create a matrix object and a vector object and multiply them.
var m = [],
v = [];
Mat4.id(m);
Vec3.set(v, 1, 1, 1);
Mat4.$mulVec3(m, v);Multiplies two Mat4. Creates a new Mat4 with the result and does not modify the original instances.
m.mulMat4(m1);
Mat4.mulMat4(m, m1);
Mat4 instance.Create two matrices and multiply them.
var m = new Mat4(),
m1 = new Mat4();
m.mulMat4(m1); //the result is a new Identity matrixCreate a two matrices objects and multiply them.
var m = [],
m1 = [];
Mat4.id(m);
Mat4.id(m1);
Mat4.mulMat4(m, m1);Multiplies two Mat4, storing the result in the receiver.
m.$mulMat4(m1);
Mat4.$mulMat4(m, m1);
Mat4 instance.Create two matrices and multiply them.
var m = new Mat4(),
m1 = new Mat4();
m.$mulMat4(m1); //the result is stored in m.Create a two matrices objects and multiply them.
var m = [],
m1 = [];
Mat4.id(m);
Mat4.id(m1);
Mat4.$mulMat4(m, m1);Multiplies two Mat4, storing the result in the receiver.
m.mulMat42(m1, m2);
Mat4.mulMat42(m, m1, m2);
Mat4 instance.Mat4 instance.Create two matrices and multiply them.
var m = new Mat4(),
m1 = new Mat4(),
m2 = new Mat4();
m.mulMat42(m1, m2); //the result is stored in m.Create a two matrices objects and multiply them.
var m = [],
m1 = [],
m2 = [];
Mat4.id(m1);
Mat4.id(m2);
Mat4.mulMat42(m, m1, m2);Adds two Mat4. Creates a new Mat4 with the result and does not modify the original instances.
m.add(m1);
Mat4.add(m, m1);
Mat4 instance.Create two matrices and add them.
var m = new Mat4(),
m1 = new Mat4();
m.add(m1); //the result is a new matrixCreate a two matrices objects and add them.
var m = [],
m1 = [];
Mat4.id(m);
Mat4.id(m1);
Mat4.add(m, m1);Adds two Mat4, storing the result in the receiver.
m.$add(m1);
Mat4.$add(m, m1);
Mat4 instance.Create two matrices and add them.
var m = new Mat4(),
m1 = new Mat4();
m.$add(m1); //the result is stored in m.Create a two matrices objects and add them.
var m = [],
m1 = [];
Mat4.id(m);
Mat4.id(m1);
Mat4.$add(m, m1);Transposes a Mat4 matrix. More info about this operation can be found here.
Creates a new Mat4 with the result.
m.transpose();
Mat4.transpose(m);
Create a Mat4 matrix and transpose it.
var m = new Mat4();
m.transpose(); //the result is a new Identity matrixTransposes a Mat4 matrix. More info about this operation can be found here.
Modifies the current matrix.
m.$transpose();
Mat4.$transpose(m);
Create a Mat4 matrix and transpose it.
var m = new Mat4();
m.$transpose(); //the result is stored in mApplies a rotation of theta by vec to a Mat4 matrix returning the result in a new matrix.
m.rotateAxis(theta, vec);
Mat4.rotateAxis(m, theta, vec);
Vec3 (or array).Create a rotation by theta and v.
var m = new Mat4(),
v = new Vec3(1, 1, 1);
m.rotateAxis(Math.PI, v); //the result is a new matrixAnother way of doing the same thing without creating a Vec3.
var m = new Mat4(),
v = [ 1, 1, 1 ];
m.rotateAxis(Math.PI, v); //the result is a new matrixApplies a rotation of angle theta by vector vec to a Mat4 altering the current matrix.
m.$rotateAxis(theta, vec);
Mat4.$rotateAxis(m, theta, vec);
Vec3 (or array).Create a rotation by theta and v.
var m = new Mat4(),
v = new Vec3(1, 1, 1);
m.$rotateAxis(Math.PI, v); //the result is in mAnother way of doing the same thing without creating a Vec3.
var m = new Mat4(),
v = [ 1, 1, 1 ];
m.$rotateAxis(Math.PI, v); //the result is in mApplies a rotation of angle rx in the x-axis, ry in the y-axis and rz in the z-axis.
Creates a new Mat4 with the result.
m.rotateXYZ(rx, ry, rz);
Mat4.rotateXYZ(m, rx, ry, rz);
Create a rotation on the x-axis.
var m = new Mat4();
m.rotateXYZ(Math.PI, 0, 0); //the result is a new matrixAnother way of doing it with generics:
var m = [];
Mat4.id(m);
Mat4.rotateXYZ(m, Math.PI, 0, 0); //creates a new Mat4 with the result.Applies a rotation of angle rx in the x-axis, ry in the y-axis and rz in the z-axis.
Alters the matrix.
m.$rotateXYZ(rx, ry, rz);
Mat4.$rotateXYZ(m, rx, ry, rz);
Create a rotation on the x-axis.
var m = new Mat4();
m.$rotateXYZ(Math.PI, 0, 0); //alters mAnother way of doing it with generics:
var m = [];
Mat4.id(m);
Mat4.$rotateXYZ(m, Math.PI, 0, 0); //alters mApplies a translation to Mat4 in the directions x, y and z.
Stores the result in a new Mat4 instance.
m.translate(x, y, z);
Mat4.translate(m, x, y, z);
Create a translation on the x-axis.
var m = new Mat4();
m.translate(10, 0, 0); //the result is a new matrixAnother way of doing it with generics:
var m = [];
Mat4.id(m);
Mat4.translate(m, 10, 0, 0); //creates a new Mat4 with the result.Applies a translation to Mat4 in the directions x, y and z.
Alters the original matrix.
m.$translate(x, y, z);
Mat4.$translate(m, x, y, z);
Create a translation on the x-axis.
var m = new Mat4();
m.$translate(10, 0, 0); //the result is in mAnother way of doing it with generics:
var m = [];
Mat4.id(m);
Mat4.$translate(m, 10, 0, 0); //the result is in mApplies scaling to Mat4 in the directions x, y and z.
Stores the result in a new Mat4 instance.
m.scale(x, y, z);
Mat4.scale(m, x, y, z);
Create a scaling on the x-axis.
var m = new Mat4();
m.scale(10, 0, 0); //the result is a new matrixAnother way of doing it with generics:
var m = [];
Mat4.id(m);
Mat4.scale(m, 10, 0, 0); //creates a new Mat4 with the result.Applies scaling to Mat4 in the directions x, y and z.
Alters the original matrix.
m.$scale(x, y, z);
Mat4.$scale(m, x, y, z);
Create a scaling on the x-axis.
var m = new Mat4();
m.$scale(10, 0, 0); //the result is in mAnother way of doing it with generics:
var m = [];
Mat4.id(m);
Mat4.$scale(m, 10, 0, 0); //the result is in mInverts a Mat4 matrix. The matrix has to be invertible.
Creates a new Mat4 with the result.
m.invert();
Mat4.invert(m);
Create a Mat4 matrix and invert it.
var m = new Mat4();
m.invert(); //the result is a new matrixInverts a Mat4 matrix. The matrix has to be invertible.
Modifies the current matrix.
m.$invert();
Mat4.$invert(m);
Create a Mat4 matrix and invert it.
var m = new Mat4();
m.$invert(); //the result is stored in mPerforms a lookAt operation on a matrix. Modifies the current matrix.
Ths method is useful when setting a camera matrix class.
For more information about the lookAt operation look here.
m.lookAt(eye, center, up);
Mat4.lookAt(m, eye, center, up);
Vec3 (or x,y,z object).Vec3 (or x,y,z object).Vec3 (or x,y,z object).Create a lookAt matrix. The eye is looking at the origin.
var m = new Mat4(),
eye = [ 1, 0, 1 ],
center = [ 0, 0, 0 ],
up = [ 0, 1, 0 ];
m.lookAt(eye, center, up); //the original matrix is modified.Another way of doing it with generics:
var m = [],
eye = [ 1, 0, 1 ],
center = [ 0, 0, 0 ],
up = [ 0, 1, 0 ];
Mat4.lookAt(m, eye, center, up); //the original object is modified.Performs a frustum operation on a matrix. Modifies the current matrix.
This method is useful when setting a camera projection matrix class.
For more information about the frustum geometry look here.
m.frustum(left, right, bottom, top, near, far);
Mat4.frustum(m, left, right, bottom, top, near, far);
Creates an orthographic projection. Modifies the current matrix.
For more information about the orthographic projection geometry look here.
m.ortho(left, right, bottom, top, near, far);
Mat4.ortho(m, left, right, bottom, top, near, far);
Creates a perspective matrix. This operation is based on creating a frustum matrix. Modifies the current matrix. This method is useful when setting a camera projection matrix class.
m.perspective(fov, aspect, near, far);
Mat4.perspective(m, fov, aspect, near, far);
canvas.width / canvas.height.Converts the matrix in a Float32Array. Useful when setting matrix uniforms.
m.toFloat32Array();
Clones a matrix.
m.clone();
Mat4.clone(m);
A class to handle Quaternions. More information on quternions can be
found here. The quaternion
will be represented by an instance with x, y, z, w components
that make a quaternion like: xi + yj + zk + w.
Create a new Quat instance from the x, y, z coordinates of a Vec3 and a real component.
Quat.fromVec3(v[, r]);
Vec3 instance.0.Create a Quaternion from a Vec3.
var v = new Vec3(1, 2, 3),
q = Quat.fromVec3(v, 7); //Quat(1, 2, 3, 7)Create a new Quat instance from a Mat4. The Mat4 instance
must be an orthogonal matrix.
Quat.fromMat4(m);
Mat4 instance.Create a Quaternion from a Mat4.
var m = new Mat4(),
q = Quat.fromMat4(m); //QuatCreate a new Quat instance from a rotation around the x-axis in
radians.
Quat.fromXRotation(angle);
Create a Quaternion from an x-axis rotation.
var q = Quat.fromXRotation(Math.PI); //Quat(1, 0, 0, 0)Create a new Quat instance from a rotation around the y-axis in
radians.
Quat.fromYRotation(angle);
Create a Quaternion from an y-axis rotation.
var q = Quat.fromYRotation(Math.PI); //Quat(0, 1, 0, 0)Create a new Quat instance from a rotation around the z-axis in
radians.
Quat.fromZRotation(angle);
Create a Quaternion from an z-axis rotation.
var q = Quat.fromZRotation(Math.PI); //Quat(0, 0, 1, 0)Create a new Quat instance from a rotation around an axis.
Quat.fromAxisRotation(v, angle);
Vec3-like object (i.e an array of three components).Create a Quaternion from an z-axis rotation.
var v = new Vec3(0, 0, 1),
q = Quat.fromAxisRotation(v, Math.PI); //Quat(0, 0, 1, 0)Creates a new Quat instance.
var q = new Quat(x, y, z, w);
Create a (0, 0, 0, 0) quaternion.
var q = new Quat();Create a (1, 2, 3, 4) quaternion.
var q = new Quat(1, 2, 3, 4);Set x, y, z, w coordinates of one Quat into another Quat.
q1.setQuat(q2);
Quat.setQuat(q1, q2);
Quat instance.Create two quaternions and assign one quaternions components to the other one.
var q1 = new Quat(1, 2, 3, 4),
q2 = new Quat(4, 5, 6, 7);
q1.setQuat(q2); //v1 now contains [ 4, 5, 6, 7 ]Set an object’s x, y, z, w components to another object.
var q1 = [],
q2 = [ 4, 5, 6, 7 ];
Quat.setQuat(q1, q2); //q1 now has [ 4, 5, 6, 7 ]Set x, y, z, w coordinates.
q1.set(x, y, z, w);
Quat.set(q1, x, y, z, w);
Create two quaternions and assign one quaternions components to the other one.
var q1 = new Quat(1, 2, 3, 4),
q2 = new Quat(4, 5, 6, 7);
q1.set(q2.x, q2.y, q2.z, q2.w); //q1 now contains [ 4, 5, 6, 7 ]Set an object’s x, y, z, w components to another object.
var q1 = [],
q2 = [ 4, 5, 6, 7 ];
Quat.set(q1, q2.x, q2.y, q2.z, q2.w); //q1 now has [ 4, 5, 6, 7 ]Adds the x, y, z components of two Quat objects. Creates a new Quat instance and does not modify the original objects.
q1.add(q2);
Quat.add(q1, q2);
Quat instance.Create two quaternions and add them.
var q1 = new Quat(1, 2, 3, 4),
q2 = new Quat(4, 5, 6, 7);
q1.add(q2); //q1 and q2 are still the same but a new Quat(5, 7, 9, 11) was created.Create two x, y, z, w objects and add them.
var q1 = [ 1, 2, 3, 4 ],
q2 = [ 4, 5, 6, 7 ];
Quat.add(q1, q2); //q1 and q2 are still the same but a new Quat(5, 7, 9, 11) was created.Adds the x, y, z, w components of two Quat objects. Modifies the original object.
q1.$add(q2);
Quat.$add(q1, q2);
Quat instance.Create two quaternions and add them.
var q1 = new Quat(1, 2, 3, 4),
q2 = new Quat(4, 5, 6, 7);
q1.$add(q2); //q1 is now Quat(5, 7, 9, 11).Create two x, y, z, w objects and add them.
var q1 = [ 1, 2, 3, 4 ],
q2 = [ 4, 5, 6, 7 ];
Quat.$add(q1, q2); //q1 is now [ 5, 7, 9, 11 ].Substracts the x, y, z, w components of two Quat objects. Creates a new Quat instance and does not modify the original objects.
q1.sub(q2);
Quat.sub(q1, q2);
Quat instance.Create two quaternions and substract them.
var q1 = new Quat(1, 2, 3, 4),
q2 = new Quat(4, 5, 6, 7);
q1.sub(q2); //q1 and q2 are still the same but a new Quat(-3, -3, -3, -3) was created.Create two x, y, z, w objects and substract them.
var q1 = {
x: 1,
y: 2,
z: 3,
w: 4
},
q2 = [ 4, 5, 6, 7 ];
Quat.sub(q1, q2); //q1 and q2 are still the same but a new Quat(-3, -3, -3, -3) was created.Substracts the x, y, z, w components of two Quat objects. Modifies the original object.
q1.$sub(q2);
Quat.$sub(q1, q2);
Quat instance.Create two quaternions and substract them.
var q1 = new Quat(1, 2, 3, 4),
q2 = new Quat(4, 5, 6, 7);
q1.$sub(q2); //q1 is now Quat(-3, -3, -3, -3).Create two x, y, z, w objects and add them.
var q1 = [ 1, 2, 3, 4 ],
q2 = [ 4, 5, 6, 7 ];
Quat.$sub(q1, q2); //q1 is now [ -3, -3, -3, -3 ].Multiplies two quaternions returning a new Quat instance with the result.
The original object is not modified.
q1.mulQuat(q2);
Quat.mulQuat(q1, q2);
Quat instance.Create two Quaternions and multiply them.
var q1 = new Quat(1, 0, 0, 0),
q2 = new Quat(1, 0, 0, 0);
q1.mulQuat(q2); //q1 is unchanged but a new Quat(-1, 0, 0, 0) is created.Multiplies two quaternions returning and modifies the receiver with the result.
q1.$mulQuat(q2);
Quat.$mulQuat(q1, q2);
Quat instance.Create two Quaternions and multiply them.
var q1 = new Quat(1, 0, 0, 0),
q2 = new Quat(1, 0, 0, 0);
q1.$mulQuat(q2); //q1 is now Quat(-1, 0, 0, 0).Divides two quaternions returning a new Quat instance with the result.
The original object is not modified.
q1.divQuat(q2);
Quat.divQuat(q1, q2);
Quat instance.Create two Quaternions and divide them.
var q1 = new Quat(1, 0, 0, 0),
q2 = new Quat(1, 0, 0, 0);
q1.divQuat(q2); //q1 is unchanged but a new Quat(1, 0, 0, 0) is created.Divides two quaternions returning and modifies the receiver with the result.
q1.$divQuat(q2);
Quat.$divQuat(q1, q2);
Quat instance.Create two Quaternions and divide them.
var q1 = new Quat(1, 0, 0, 0),
q2 = new Quat(1, 0, 0, 0);
q1.$divQuat(q2); //q1 is now Quat(1, 0, 0, 0).Scales the Quat quaternion by a real number. Creates a new Quat with the scaled components.
q1.scale(s);
Quat.scale(q1, s);
Create a quaternion and scale it by 2.
var q1 = new Quat(1, 2, 3, 4);
q1.scale(2); //q1 is unchanged but a new Quat(2, 4, 6, 8) is created.Create an x, y, z, w object and scale it by 2.
var q1 = [ 1, 2, 3, 4 ];
Quat.scale(q1, 2); //q1 is still the same but a new Quat(2, 4, 6, 8) was created.Scales the Quat quaternion by a real number. Changes the original object.
q1.$scale(s);
Quat.$scale(q1, s);
Create a quaternion and scale it by 2.
var q1 = new Quat(1, 2, 3, 4);
q1.$scale(2); //q1 is now Quat(2, 4, 6, 8).Create an x, y, z, w object and scale it by 2.
var q1 = [ 1, 2, 3, 4 ];
Quat.$scale(q1, 2); //q1 is now [ 2, 4, 6, 8 ].Conjugates a Quat. Returns a new instance.
q1.conjugate();
Quat.conjugate(q1);
Create a quaternion and conjugate it.
var q1 = new Quat(1, 2, 3, 4);
q1.conjugate(); //q1 is unchanged but a new Quat(-1, -2, -3, 4) is created.Create an x, y, z, w object and conjugate it.
var q1 = [ 1, 2, 3, 4 ];
Quat.conjugate(q1); //q1 is still the same but a new Quat(-1, -2, -3, 4).conjugates a Quat. Changes the original object.
q1.$conjugate();
Quat.$conjugate(q1);
Create a quaternion and conjugate it.
var q1 = new Quat(1, 2, 3, 4);
q1.$conjugate(); //q1 is now Quat(-1, -2, -3, 4).Create an x, y, z, w object and conjugate it.
var q1 = [ 1, 2, 3, 4 ];
Quat.conjugate(q1); //q1 is now [ -1, -2, -3, 4 ].Negates a Quat. Returns a new instance.
q1.neg();
Quat.neg(q1);
Create a quaternion and negate it.
var q1 = new Quat(1, 2, 3, 4);
q1.neg(); //q1 is unchanged but a new Quat(-1, -2, -3, -4) is created.Create an x, y, z, w object and negate it.
var q1 = [ 1, 2, 3, 4 ];
Quat.neg(q1); //q1 is still the same but a new Quat(-1, -2, -3, -4).Negates a Quat. Changes the original object.
q1.$neg();
Quat.$neg(q1);
Create a quaternion and negate it.
var q1 = new Quat(1, 2, 3, 4);
q1.$neg(); //q1 is now Quat(-1, -2, -3, -4).Create an x, y, z, w object and negate it.
var q1 = [ 1, 2, 3, 4 ];
Quat.neg(q1); //q1 is now [ -1, -2, -3, -4 ].Creates a unit quaternion from the coordinates of Quat. The original
object is not modified.
q1.unit();
Quat.unit(q1);
Create a quaternion and make a unit quaternion from it.
var q1 = new Quat(1, 2, 3, 4);
q1.unit(); //q1 is unchanged but a new unit quaternion Quat is created.Create an x, y, z, w object and make a unit quaternion from it.
var q1 = [ 1, 2, 3, 4 ];
Quat.unit(q1); //q1 is still the same but a new Quat that is a unit quaternion is created.Creates a unit quaternion from the Quat coordinates. Changes the original object.
q1.$unit();
Quat.$unit(q1);
Create a quaternion and make a unit quaternion from it.
var q1 = new Quat(1, 2, 3, 4);
q1.$unit(); //q1 is now a unit quaternion.Create an x, y, z, w object and make a unit quaternion from it.
var q1 = [ 1, 2, 3, 4 ];
Quat.$unit(q1); //q1 is now a unit quaternion vector.Calculates the norm of Quat.
q1.norm();
Quat.norm(q1);
Create a quaternion and calculate its norm.
var q1 = new Quat(1, 2, 3, 4);
vi.norm(); //returns the real valued norm.Create an x, y, z, w object and calculate its norm.
var q1 = [ 1, 2, 3, 4 ];
//A real number with the norm is returned.
var ans = Quat.norm(q1);Calculates the squared norm of Quat.
q1.normSq();
Quat.normSq(q1);
Create a quaternion and calculate its squared norm.
var q1 = new Quat(1, 2, 3, 4);
vi.normSq(); //returns the real valued norm.Create an x, y, z, w object and calculate its squared norm.
var q1 = [ 1, 2, 3, 4 ];
//A real number with the squared norm is returned.
var ans = Quat.normSq(q1);Clones a quaternion.
q1.clone();
Quat.clone(q1);