archive-gh-me/luma.gl
1
0
Fork 0
mirror of https://github.com/visgl/luma.gl.git synced 2026-01-25 14:08:58 +00:00
Code Issues Projects Releases Wiki Activity
luma.gl/docs/api-reference/math/math.md
Ib Green a2901e3236 Update docs for v4 and WebGL2 (#159)
2017-05-01 20:13:22 -07:00

2631 lines
52 KiB
Markdown
Raw Blame History

---
layout: docs
title: Math
categories: [Documentation]
---
Script: Math {#Math}
===========================
The Math script provides `Vec3`, `Mat4` and `Quat` classes to manage three dimensional vectors, four by four matrices and quaternions respectively.
### Generics:
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.
### Chainable Methods:
All methods that do not return something in particular in the math package are chainable.
### Conventions:
Say you want to add two `Vec3` vectors, `v1` and `v2`. Then there are three ways of performing this operation:
1. `v1.add(v2)` Returns a new instance with the result of adding `v1` and `v2`. This operation does not modify `v1` or `v2`.
2. `v1.$add(v2)` Returns the result of adding `v1` to `v2`, but it alters `v1` updating it with the result.
3. `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`.
### Notes:
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.
Class: Vec3 {#Vec3}
===========================
A class to handle three dimensional vectors.
Vec3 Static Method: fromQuat {#Vec3:fromQuat}
-----------------------------------------------
Create a new `Vec3` instance from the `x`, `y`, `z` coordinates of a [Quat](#Quat).
### Syntax:
Vec3.fromQuat(q);
### Arguments:
1. q - (*object*) A `Quat` instance.
### Examples:
Create a vector from a Quaternion.
{% highlight js %}
var q = new Quat(1, 2, 3, 4),
v = Vec3.fromQuat(q); //Vec3(1, 2, 3)
{% endhighlight %}
Vec3 Method: constructor {#Vec3:constructor}
----------------------------------------------------
Creates a new `Vec3` instance.
### Syntax:
var v = new Vec3(x, y, z);
### Arguments:
1. x - (*number*, optional) The x component. If not provided is 0.
2. y - (*number*, optional) The y component. If not provided is 0.
3. z - (*number*, optional) The z component. If not provided is 0.
### Examples:
Create a (0, 0, 0) vector.
{% highlight js %}
var v = new Vec3();
{% endhighlight %}
Create a (1, 2, 3) vector.
{% highlight js %}
var v = new Vec3(1, 2, 3);
{% endhighlight %}
Vec3 Method: setVec3 {#Vec3:setVec3}
------------------------------------
Set `x`, `y`, `z` coordinates of one `Vec3` into another `Vec3`.
### Syntax:
v1.setVec3(v2);
Vec3.setVec3(v1, v2);
### Arguments:
1. v2 - (*object*) A `Vec3` instance.
### Examples:
Create two vectors and assign one vectors components to the other one.
{% highlight js %}
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)
{% endhighlight %}
Set an object's `x`, `y`, `z` components to another object.
{% highlight js %}
var v1 = [],
v2 = [ 4, 5, 6 ];
Vec3.setVec3(v1, v2); //v1 now has [4, 5, 6]
{% endhighlight %}
Vec3 Method: set {#Vec3:set}
-------------------------------
Set `x`, `y`, `z` coordinates.
### Syntax:
v1.set(x, y, z);
Vec3.set(v1, x, y, z);
### Arguments:
1. x - (*number*) The x coordinate.
2. y - (*number*) The y coordinate.
3. z - (*number*) The z coordinate.
### Examples:
Create two vectors and assign one vectors components to the other one.
{% highlight js %}
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)
{% endhighlight %}
Set an object's `x`, `y`, `z` components to another object.
{% highlight js %}
var v1 = [],
v2 = [ 4, 5, 6 ];
Vec3.set(v1, v2.x, v2.y, v2.z); //v1 now has [4, 5, 6]
{% endhighlight %}
Vec3 Method: add {#Vec3:add}
-----------------------------
Adds the `x`, `y`, `z` components of two `Vec3` objects. Creates a new `Vec3` instance and does not modify the original objects.
### Syntax:
v1.add(v2);
Vec3.add(v1, v2);
### Arguments:
1. v2 - (*object*) A `Vec3` instance.
### Examples:
Create two vectors and add them.
{% highlight js %}
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.
{% endhighlight %}
Create two `x`, `y`, `z` objects and add them.
{% highlight js %}
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.
{% endhighlight %}
Vec3 Method: $add {#Vec3:$add}
------------------------------------
Adds the `x`, `y`, `z` components of two `Vec3` objects. Modifies the original object.
### Syntax:
v1.$add(v2);
Vec3.$add(v1, v2);
### Arguments:
1. v2 - (*object*) A `Vec3` instance.
### Examples:
Create two vectors and add them.
{% highlight js %}
var v1 = new Vec3(1, 2, 3),
v2 = new Vec3(4, 5, 6);
v1.$add(v2); //v1 is now Vec3(5, 7, 9).
{% endhighlight %}
Create two `x`, `y`, `z` objects and add them.
{% highlight js %}
var v1 = [ 1, 2, 3 ],
v2 = [ 4, 5, 6 ];
Vec3.$add(v1, v2); //v1 is now [ 5, 7, 9 ].
{% endhighlight %}
Vec3 Method: add2 {#Vec3:add2}
------------------------------------
Adds the `x`, `y`, `z` components of two `Vec3` objects and stores the result in the receiver.
### Syntax:
v1.add2(v2, v3);
Vec3.add2(v1, v2, v3);
### Arguments:
1. v2 - (*object*) A `Vec3` instance.
2. v3 - (*object*) A `Vec3` instance.
### Examples:
Create two vectors and add them.
{% highlight js %}
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.
{% endhighlight %}
Create two `x`, `y`, `z` objects and add them.
{% highlight js %}
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 ].
{% endhighlight %}
Vec3 Method: sub {#Vec3:sub}
------------------------------------
Substracts the `x`, `y`, `z` components of two `Vec3` objects. Creates a new `Vec3` instance and does not modify the original objects.
### Syntax:
v1.sub(v2);
Vec3.sub(v1, v2);
### Arguments:
1. v2 - (*object*) A `Vec3` instance.
### Examples:
Create two vectors and substract them.
{% highlight js %}
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.
{% endhighlight %}
Create two `x`, `y`, `z` objects and substract them.
{% highlight js %}
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.
{% endhighlight %}
Vec3 Method: $sub {#Vec3:$sub}
------------------------------------
Substracts the `x`, `y`, `z` components of two `Vec3` objects. Modifies the original object.
### Syntax:
v1.$sub(v2);
Vec3.$sub(v1, v2);
### Arguments:
1. v2 - (*object*) A `Vec3` instance.
### Examples:
Create two vectors and substract them.
{% highlight js %}
var v1 = new Vec3(1, 2, 3),
v2 = new Vec3(4, 5, 6);
v1.$sub(v2); //v1 is now Vec3(-3, -3, -3).
{% endhighlight %}
Create two `x`, `y`, `z` objects and add them.
{% highlight js %}
var v1 = [ 1, 2, 3 ],
v2 = [ 4, 5, 6 ];
Vec3.$sub(v1, v2); //v1 is now [ -3, -3, -3 ].
{% endhighlight %}
Vec3 Method: sub2 {#Vec3:sub2}
------------------------------------
Substracts the `x`, `y`, `z` components of two `Vec3` objects and stores the result in the receiver.
### Syntax:
v1.sub2(v2, v3);
Vec3.sub2(v1, v2, v3);
### Arguments:
1. v2 - (*object*) A `Vec3` instance.
2. v3 - (*object*) A `Vec3` instance.
### Examples:
Create two vectors and substract them.
{% highlight js %}
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.
{% endhighlight %}
Create two `x`, `y`, `z` objects and substract them.
{% highlight js %}
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 }.
{% endhighlight %}
Vec3 Method: scale {#Vec3:scale}
------------------------------------
Scales the Vec3 vector by a real number. Creates a new Vec3 with the scaled components.
### Syntax:
v1.scale(s);
Vec3.scale(v1, s);
### Arguments:
1. s - (*number*) A real number to scale the Vec3.
### Examples:
Create a vector and scale it by 2.
{% highlight js %}
var v1 = new Vec3(1, 2, 3);
v1.scale(2); //v1 is unchanged but a new Vec3(2, 4, 6) is created.
{% endhighlight %}
Create an `x`, `y`, `z` object and scale it by 2.
{% highlight js %}
var v1 = [ 1, 2, 3 ];
Vec3.scale(v1, 2); //v1 is still the same but a new Vec3(2, 4, 6) was created.
{% endhighlight %}
Vec3 Method: $scale {#Vec3:$scale}
------------------------------------
Scales the Vec3 vector by a real number. Changes the original object.
### Syntax:
v1.$scale(s);
Vec3.$scale(v1, s);
### Arguments:
1. s - (*number*) A real number to scale the Vec3.
### Examples:
Create a vector and scale it by 2.
{% highlight js %}
var v1 = new Vec3(1, 2, 3);
v1.$scale(2); //v1 is now Vec3(2, 4, 6).
{% endhighlight %}
Create an `x`, `y`, `z` object and scale it by 2.
{% highlight js %}
var v1 = [ 1, 2, 3 ];
Vec3.$scale(v1, 2); //v1 is now [ 2, 4, 6 ].
{% endhighlight %}
Vec3 Method: neg {#Vec3:neg}
------------------------------------
Negates a `Vec3`. Returns a new instance.
### Syntax:
v1.neg();
Vec3.neg(v1);
### Examples:
Create a vector and negate it.
{% highlight js %}
var v1 = new Vec3(1, 2, 3);
v1.neg(); //v1 is unchanged but a new Vec3(-1, -2, -3) is created.
{% endhighlight %}
Create an `x`, `y`, `z` object and negate it.
{% highlight js %}
var v1 = [ 1, 2, 3 ];
Vec3.neg(v1); //v1 is still the same but a new Vec3(-1, -2, -3).
{% endhighlight %}
Vec3 Method: $neg {#Vec3:$neg}
------------------------------------
Negates a `Vec3`. Changes the original object.
### Syntax:
v1.$neg();
Vec3.$neg(v1);
### Examples:
Create a vector and negate it.
{% highlight js %}
var v1 = new Vec3(1, 2, 3);
v1.$neg(); //v1 is now Vec3(-1, -2, -3).
{% endhighlight %}
Create an `x`, `y`, `z` object and negate it.
{% highlight js %}
var v1 = [ 1, 2, 3 ];
Vec3.neg(v1); //v1 is now [ -1, -2, -3 ].
{% endhighlight %}
Vec3 Method: unit {#Vec3:unit}
------------------------------------
Creates a unit vector from the coordinates of `Vec3`.
### Syntax:
v1.unit();
Vec3.unit(v1);
### Examples:
Create a vector and make a unit vector from it.
{% highlight js %}
var v1 = new Vec3(1, 2, 3);
v1.unit(); //v1 is unchanged but a new unit vector Vec3 is created.
{% endhighlight %}
Create an `x`, `y`, `z` object and make a unit vector from it.
{% highlight js %}
var v1 = [ 1, 2, 3 ];
Vec3.unit(v1); //v1 is still the same but a new Vec3 that is a unit vector is created.
{% endhighlight %}
Vec3 Method: $unit {#Vec3:$unit}
------------------------------------
Creates a unit vector from the `Vec3` coordinates. Changes the original object.
### Syntax:
v1.$unit();
Vec3.$unit(v1);
### Examples:
Create a vector and make a unit vector from it.
{% highlight js %}
var v1 = new Vec3(1, 2, 3);
v1.$unit(); //v1 is now a unit vector.
{% endhighlight %}
Create an `x`, `y`, `z` object make a unit vector from it.
{% highlight js %}
var v1 = [ 1, 2, 3 ];
Vec3.$unit(v1); //v1 is now a unit vector object.
{% endhighlight %}
Vec3 Method: cross {#Vec3:cross}
------------------------------------
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](http://en.wikipedia.org/wiki/Cross_product).
### Syntax:
v1.cross(v2);
Vec3.cross(v1, v2);
### Arguments:
1. v2 - (*object*) A `Vec3` instance.
### Examples:
Create two vectors and make a cross product.
{% highlight js %}
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.
{% endhighlight %}
Create two `x`, `y`, `z` objects and make a cross product.
{% highlight js %}
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);
{% endhighlight %}
Vec3 Method: $cross {#Vec3:$cross}
------------------------------------
Makes a cross product of two `Vec3` instances. Modifies the original object.
You can find more information about the cross product [here](http://en.wikipedia.org/wiki/Cross_product).
### Syntax:
v1.$cross(v2);
Vec3.$cross(v1, v2);
### Arguments:
1. v2 - (*object*) A `Vec3` instance.
### Examples:
Create two vectors and make a cross product.
{% highlight js %}
var v1 = new Vec3(1, 2, 3),
v2 = new Vec3(4, 5, 6);
v1.$cross(v2); //v1 contains now the result.
{% endhighlight %}
Create two `x`, `y`, `z` objects and make a cross product.
{% highlight js %}
var v1 = [ 1, 2, 3 ],
v2 = [ 4, 5, 6 ];
//v1 contains now the result.
var ans = Vec3.$cross(v1, v2);
{% endhighlight %}
Vec3 Method: distTo {#Vec3:distTo}
------------------------------------
Calculates the distance between two `Vec3`.
### Syntax:
v1.distTo(v2);
Vec3.distTo(v1, v2);
### Arguments:
1. v2 - (*object*) A `Vec3` instance.
### Examples:
Create two vectors and calculate the distance.
{% highlight js %}
var v1 = new Vec3(1, 2, 3),
v2 = new Vec3(4, 5, 6);
v1.distTo(v2); //a real value with the distance is returned.
{% endhighlight %}
Create two `x`, `y`, `z` objects and calculate their distance.
{% highlight js %}
var v1 = [ 1, 2, 3 ],
v2 = [ 4, 5, 6 ];
//a real number with the distance is returned.
var ans = Vec3.distTo(v1, v2);
{% endhighlight %}
Vec3 Method: distToSq {#Vec3:distToSq}
------------------------------------
Calculates the squared distance between two `Vec3`.
### Syntax:
v1.distToSq(v2);
Vec3.distToSq(v1, v2);
### Arguments:
1. v2 - (*object*) A `Vec3` instance.
### Examples:
Create two vectors and calculate the squared distance.
{% highlight js %}
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.
{% endhighlight %}
Create two `x`, `y`, `z` objects and calculate their squared distance.
{% highlight js %}
var v1 = [ 1, 2, 3 ],
v2 = [ 4, 5, 6 ];
//a real number with the squared distance is returned.
var ans = Vec3.distToSq(v1, v2);
{% endhighlight %}
Vec3 Method: norm {#Vec3:norm}
------------------------------------
Calculates the norm of `Vec3`.
### Syntax:
v1.norm();
Vec3.norm(v1);
### Examples:
Create a vector and calculate its norm.
{% highlight js %}
var v1 = new Vec3(1, 2, 3);
vi.norm(); //returns the real valued norm.
{% endhighlight %}
Create an `x`, `y`, `z` object and calculate its norm.
{% highlight js %}
var v1 = [ 1, 2, 3 ];
//A real number with the norm is returned.
var ans = Vec3.norm(v1);
{% endhighlight %}
Vec3 Method: normSq {#Vec3:normSq}
------------------------------------
Calculates the squared norm of `Vec3`.
### Syntax:
v1.normSq();
Vec3.normSq(v1);
### Examples:
Create a vector and calculate its squared norm.
{% highlight js %}
var v1 = new Vec3(1, 2, 3);
vi.normSq(); //returns the real valued norm.
{% endhighlight %}
Create an `x`, `y`, `z` object and calculate its squared norm.
{% highlight js %}
var v1 = [ 1, 2, 3 ];
//A real number with the squared norm is returned.
var ans = Vec3.normSq(v1);
{% endhighlight %}
Vec3 Method: dot {#Vec3:dot}
------------------------------------
Calculates the dot product between two `Vec3`. You can find more information about the
dot product [here](http://en.wikipedia.org/wiki/Dot_product).
### Syntax:
v1.dot(v2);
Vec3.dot(v1, v2);
### Arguments:
1. v2 - (*object*) A `Vec3` instance.
### Examples:
Create two vectors and calculate the dot product.
{% highlight js %}
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.
{% endhighlight %}
Create two `x`, `y`, `z` objects and calculate the dot product.
{% highlight js %}
var v1 = [ 1, 2, 3 ],
v2 = [ 4, 5, 6 ];
//a real number with the dot product is returned.
var ans = Vec3.dot(v1, v2);
{% endhighlight %}
Vec3 Method: clone {#Vec3:clone}
------------------------------------
Clones a vector.
### Syntax:
v1.clone();
Vec3.clone(v1);
Class: Mat4 {#Mat4}
===========================
A class to handle four by four matrices.
Mat4 Static Method: fromQuat {#Mat4:fromQuat}
-----------------------------------------------
Create a new `Mat4` instance from a [Quat](#Quat) instance. The
Quaternion must be a unit quaternion.
### Syntax:
Mat4.fromQuat(q);
### Arguments:
1. q - (*object*) A `Quat` instance.
### Examples:
Create a matrix from a Quaternion.
{% highlight js %}
var q = new Quat(1, 2, 3, 4).$unit(),
m = Mat4.fromQuat(q); //a new Mat4 instance
{% endhighlight %}
Mat4 Method: constructor {#Mat4:constructor}
----------------------------------------------
Creates a new `Mat4` instance. If no arguments are set then an Identity matrix is created.
### Syntax:
var m = new Mat4();
var m = new Mat4(n11, n12, n13, n14,
n21, n22, n23, n24,
n31, n32, n33, n34,
n41, n42, n43, n44);
### Arguments:
1. n - (*number*) The matrix component.
### Examples:
Create an identity matrix.
{% highlight js %}
var m = new Mat4();
{% endhighlight %}
Create a null matrix.
{% highlight js %}
var m = new Mat4( 0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0 );
{% endhighlight %}
Mat4 Method: id {#Mat4:id}
---------------------------
Modifies the matrix to be an Identity matrix.
### Syntax:
m.id();
Mat4.id(m);
### Examples:
Create an identity matrix from some random matrix.
{% highlight js %}
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.
{% endhighlight %}
Create an identity matrix object.
{% highlight js %}
var m = [];
Mat4.id(m); //m object components are the Identity matrix ones.
{% endhighlight %}
Mat4 Method: set {#Mat4:set}
-------------------------------
Set all matrix coordinates.
### Syntax:
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);
### Arguments:
1. n - (*number*) The n matrix coordinates.
### Examples:
Create a matrix and set some values to it.
{% highlight js %}
var m = new Mat4();
m.set(1, 2, 3, 4,
1, 2, 3, 4,
1, 2, 3, 4,
1, 2, 3, 4);
{% endhighlight %}
Set an empty object matrix coordinates onto some values.
{% highlight js %}
var m = [];
Mat4.set(m, 1, 2, 3, 4,
1, 2, 3, 4,
1, 2, 3, 4,
1, 2, 3, 4);
{% endhighlight %}
Mat4 Method: mulVec3 {#Mat4:mulVec3}
-------------------------------------
Multiplies a `Mat4` by a `Vec3`. Returns a new `Vec3` without modifying the passed in object.
### Syntax:
m.mulVec3(v);
Mat4.mulVec3(m, v);
### Arguments:
1. v - (*object*) A `Vec3` instance.
### Examples:
Create a matrix and a vector and multiply them.
{% highlight js %}
var m = new Mat4(),
v = new Vec3(1, 1, 1);
m.mulVec3(v);
{% endhighlight %}
Create a matrix object and a vector object and multiply them.
{% highlight js %}
var m = [],
v = [];
Mat4.id(m);
Vec3.set(v, 1, 1, 1);
Mat4.mulVec3(m, v);
{% endhighlight %}
Mat4 Method: $mulVec3 {#Mat4:$mulVec3}
-------------------------------------
Multiplies a `Mat4` by a `Vec3`. Modifies the receiver.
### Syntax:
m.$mulVec3(v);
Mat4.$mulVec3(m, v);
### Arguments:
1. v - (*object*) A `Vec3` instance.
### Examples:
Create a matrix and a vector and multiply them.
{% highlight js %}
var m = new Mat4(),
v = new Vec3(1, 1, 1);
m.$mulVec3(v);
{% endhighlight %}
Create a matrix object and a vector object and multiply them.
{% highlight js %}
var m = [],
v = [];
Mat4.id(m);
Vec3.set(v, 1, 1, 1);
Mat4.$mulVec3(m, v);
{% endhighlight %}
Mat4 Method: mulMat4 {#Mat4:mulMat4}
-------------------------------------
Multiplies two `Mat4`. Creates a new `Mat4` with the result and does not modify the original instances.
### Syntax:
m.mulMat4(m1);
Mat4.mulMat4(m, m1);
### Arguments:
1. m1 - (*object*) A `Mat4` instance.
### Examples:
Create two matrices and multiply them.
{% highlight js %}
var m = new Mat4(),
m1 = new Mat4();
m.mulMat4(m1); //the result is a new Identity matrix
{% endhighlight %}
Create a two matrices objects and multiply them.
{% highlight js %}
var m = [],
m1 = [];
Mat4.id(m);
Mat4.id(m1);
Mat4.mulMat4(m, m1);
{% endhighlight %}
Mat4 Method: $mulMat4 {#Mat4:$mulMat4}
-------------------------------------
Multiplies two `Mat4`, storing the result in the receiver.
### Syntax:
m.$mulMat4(m1);
Mat4.$mulMat4(m, m1);
### Arguments:
1. m1 - (*object*) A `Mat4` instance.
### Examples:
Create two matrices and multiply them.
{% highlight js %}
var m = new Mat4(),
m1 = new Mat4();
m.$mulMat4(m1); //the result is stored in m.
{% endhighlight %}
Create a two matrices objects and multiply them.
{% highlight js %}
var m = [],
m1 = [];
Mat4.id(m);
Mat4.id(m1);
Mat4.$mulMat4(m, m1);
{% endhighlight %}
Mat4 Method: mulMat42 {#Mat4:mulMat42}
-------------------------------------
Multiplies two `Mat4`, storing the result in the receiver.
### Syntax:
m.mulMat42(m1, m2);
Mat4.mulMat42(m, m1, m2);
### Arguments:
1. m1 - (*object*) A `Mat4` instance.
2. m2 - (*object*) A `Mat4` instance.
### Examples:
Create two matrices and multiply them.
{% highlight js %}
var m = new Mat4(),
m1 = new Mat4(),
m2 = new Mat4();
m.mulMat42(m1, m2); //the result is stored in m.
{% endhighlight %}
Create a two matrices objects and multiply them.
{% highlight js %}
var m = [],
m1 = [],
m2 = [];
Mat4.id(m1);
Mat4.id(m2);
Mat4.mulMat42(m, m1, m2);
{% endhighlight %}
Mat4 Method: add {#Mat4:add}
-------------------------------------
Adds two `Mat4`. Creates a new `Mat4` with the result and does not modify the original instances.
### Syntax:
m.add(m1);
Mat4.add(m, m1);
### Arguments:
1. m1 - (*object*) A `Mat4` instance.
### Examples:
Create two matrices and add them.
{% highlight js %}
var m = new Mat4(),
m1 = new Mat4();
m.add(m1); //the result is a new matrix
{% endhighlight %}
Create a two matrices objects and add them.
{% highlight js %}
var m = [],
m1 = [];
Mat4.id(m);
Mat4.id(m1);
Mat4.add(m, m1);
{% endhighlight %}
Mat4 Method: $add {#Mat4:$add}
-------------------------------------
Adds two `Mat4`, storing the result in the receiver.
### Syntax:
m.$add(m1);
Mat4.$add(m, m1);
### Arguments:
1. m1 - (*object*) A `Mat4` instance.
### Examples:
Create two matrices and add them.
{% highlight js %}
var m = new Mat4(),
m1 = new Mat4();
m.$add(m1); //the result is stored in m.
{% endhighlight %}
Create a two matrices objects and add them.
{% highlight js %}
var m = [],
m1 = [];
Mat4.id(m);
Mat4.id(m1);
Mat4.$add(m, m1);
{% endhighlight %}
Mat4 Method: transpose {#Mat4:transpose}
-------------------------------------
Transposes a `Mat4` matrix. More info about this operation can be found [here](http://en.wikipedia.org/wiki/Matrix_transpose).
Creates a new `Mat4` with the result.
### Syntax:
m.transpose();
Mat4.transpose(m);
### Examples:
Create a `Mat4` matrix and transpose it.
{% highlight js %}
var m = new Mat4();
m.transpose(); //the result is a new Identity matrix
{% endhighlight %}
Mat4 Method: $transpose {#Mat4:$transpose}
-------------------------------------
Transposes a `Mat4` matrix. More info about this operation can be found [here](http://en.wikipedia.org/wiki/Matrix_transpose).
Modifies the current matrix.
### Syntax:
m.$transpose();
Mat4.$transpose(m);
### Examples:
Create a `Mat4` matrix and transpose it.
{% highlight js %}
var m = new Mat4();
m.$transpose(); //the result is stored in m
{% endhighlight %}
Mat4 Method: rotateAxis {#Mat4:rotateAxis}
-------------------------------------------
Applies a rotation of `theta` by `vec` to a `Mat4` matrix returning the result in a new matrix.
### Syntax:
m.rotateAxis(theta, vec);
Mat4.rotateAxis(m, theta, vec);
### Arguments:
1. theta - (*number*) An angle in radians.
2. vec - (*object*) A `Vec3` (or array).
### Examples:
Create a rotation by `theta` and `v`.
{% highlight js %}
var m = new Mat4(),
v = new Vec3(1, 1, 1);
m.rotateAxis(Math.PI, v); //the result is a new matrix
{% endhighlight %}
Another way of doing the same thing without creating a `Vec3`.
{% highlight js %}
var m = new Mat4(),
v = [ 1, 1, 1 ];
m.rotateAxis(Math.PI, v); //the result is a new matrix
{% endhighlight %}
Mat4 Method: $rotateAxis {#Mat4:$rotateAxis}
-------------------------------------------
Applies a rotation of angle `theta` by vector `vec` to a `Mat4` altering the current matrix.
### Syntax:
m.$rotateAxis(theta, vec);
Mat4.$rotateAxis(m, theta, vec);
### Arguments:
1. theta - (*number*) An angle in radians.
2. vec - (*object*) A `Vec3` (or array).
### Examples:
Create a rotation by `theta` and `v`.
{% highlight js %}
var m = new Mat4(),
v = new Vec3(1, 1, 1);
m.$rotateAxis(Math.PI, v); //the result is in m
{% endhighlight %}
Another way of doing the same thing without creating a `Vec3`.
{% highlight js %}
var m = new Mat4(),
v = [ 1, 1, 1 ];
m.$rotateAxis(Math.PI, v); //the result is in m
{% endhighlight %}
Mat4 Method: rotateXYZ {#Mat4:rotateXYZ}
-------------------------------------------
Applies 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.
### Syntax:
m.rotateXYZ(rx, ry, rz);
Mat4.rotateXYZ(m, rx, ry, rz);
### Arguments:
1. rx - (*number*) An angle in radians.
2. ry - (*number*) An angle in radians.
3. rz - (*number*) An angle in radians.
### Examples:
Create a rotation on the x-axis.
{% highlight js %}
var m = new Mat4();
m.rotateXYZ(Math.PI, 0, 0); //the result is a new matrix
{% endhighlight %}
Another way of doing it with generics:
{% highlight js %}
var m = [];
Mat4.id(m);
Mat4.rotateXYZ(m, Math.PI, 0, 0); //creates a new Mat4 with the result.
{% endhighlight %}
Mat4 Method: $rotateXYZ {#Mat4:$rotateXYZ}
-------------------------------------------
Applies a rotation of angle `rx` in the x-axis, `ry` in the y-axis and `rz` in the z-axis.
Alters the matrix.
### Syntax:
m.$rotateXYZ(rx, ry, rz);
Mat4.$rotateXYZ(m, rx, ry, rz);
### Arguments:
1. rx - (*number*) An angle in radians.
2. ry - (*number*) An angle in radians.
3. rz - (*number*) An angle in radians.
### Examples:
Create a rotation on the x-axis.
{% highlight js %}
var m = new Mat4();
m.$rotateXYZ(Math.PI, 0, 0); //alters m
{% endhighlight %}
Another way of doing it with generics:
{% highlight js %}
var m = [];
Mat4.id(m);
Mat4.$rotateXYZ(m, Math.PI, 0, 0); //alters m
{% endhighlight %}
Mat4 Method: translate {#Mat4:translate}
-------------------------------------------
Applies a translation to `Mat4` in the directions `x`, `y` and `z`.
Stores the result in a new `Mat4` instance.
### Syntax:
m.translate(x, y, z);
Mat4.translate(m, x, y, z);
### Arguments:
1. x - (*number*) The amount to be translated in the x direction.
2. y - (*number*) The amount to be translated in the y direction.
3. z - (*number*) The amount to be translated in the z direction..
### Examples:
Create a translation on the x-axis.
{% highlight js %}
var m = new Mat4();
m.translate(10, 0, 0); //the result is a new matrix
{% endhighlight %}
Another way of doing it with generics:
{% highlight js %}
var m = [];
Mat4.id(m);
Mat4.translate(m, 10, 0, 0); //creates a new Mat4 with the result.
{% endhighlight %}
Mat4 Method: $translate {#Mat4:$translate}
-------------------------------------------
Applies a translation to `Mat4` in the directions `x`, `y` and `z`.
Alters the original matrix.
### Syntax:
m.$translate(x, y, z);
Mat4.$translate(m, x, y, z);
### Arguments:
1. x - (*number*) The amount to be translated in the x direction.
2. y - (*number*) The amount to be translated in the y direction.
3. z - (*number*) The amount to be translated in the z direction..
### Examples:
Create a translation on the x-axis.
{% highlight js %}
var m = new Mat4();
m.$translate(10, 0, 0); //the result is in m
{% endhighlight %}
Another way of doing it with generics:
{% highlight js %}
var m = [];
Mat4.id(m);
Mat4.$translate(m, 10, 0, 0); //the result is in m
{% endhighlight %}
Mat4 Method: scale {#Mat4:scale}
-------------------------------------------
Applies scaling to `Mat4` in the directions `x`, `y` and `z`.
Stores the result in a new `Mat4` instance.
### Syntax:
m.scale(x, y, z);
Mat4.scale(m, x, y, z);
### Arguments:
1. x - (*number*) The amount to be scaled in the x direction.
2. y - (*number*) The amount to be scaled in the y direction.
3. z - (*number*) The amount to be scaled in the z direction..
### Examples:
Create a scaling on the x-axis.
{% highlight js %}
var m = new Mat4();
m.scale(10, 0, 0); //the result is a new matrix
{% endhighlight %}
Another way of doing it with generics:
{% highlight js %}
var m = [];
Mat4.id(m);
Mat4.scale(m, 10, 0, 0); //creates a new Mat4 with the result.
{% endhighlight %}
Mat4 Method: $scale {#Mat4:$scale}
-------------------------------------------
Applies scaling to `Mat4` in the directions `x`, `y` and `z`.
Alters the original matrix.
### Syntax:
m.$scale(x, y, z);
Mat4.$scale(m, x, y, z);
### Arguments:
1. x - (*number*) The amount to be scaled in the x direction.
2. y - (*number*) The amount to be scaled in the y direction.
3. z - (*number*) The amount to be scaled in the z direction..
### Examples:
Create a scaling on the x-axis.
{% highlight js %}
var m = new Mat4();
m.$scale(10, 0, 0); //the result is in m
{% endhighlight %}
Another way of doing it with generics:
{% highlight js %}
var m = [];
Mat4.id(m);
Mat4.$scale(m, 10, 0, 0); //the result is in m
{% endhighlight %}
Mat4 Method: invert {#Mat4:invert}
-------------------------------------
Inverts a `Mat4` matrix. The matrix has to be invertible.
Creates a new `Mat4` with the result.
### Syntax:
m.invert();
Mat4.invert(m);
### Examples:
Create a `Mat4` matrix and invert it.
{% highlight js %}
var m = new Mat4();
m.invert(); //the result is a new matrix
{% endhighlight %}
Mat4 Method: $invert {#Mat4:$invert}
-------------------------------------
Inverts a `Mat4` matrix. The matrix has to be invertible.
Modifies the current matrix.
### Syntax:
m.$invert();
Mat4.$invert(m);
### Examples:
Create a `Mat4` matrix and invert it.
{% highlight js %}
var m = new Mat4();
m.$invert(); //the result is stored in m
{% endhighlight %}
Mat4 Method: lookAt {#Mat4:lookAt}
-----------------------------------
Performs 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](http://www.euclideanspace.com/maths/algebra/vectors/lookat/index.htm).
### Syntax:
m.lookAt(eye, center, up);
Mat4.lookAt(m, eye, center, up);
### Arguments:
1. eye - (*object*) The eye position as a `Vec3` (or x,y,z object).
2. center - (*number*) The center position as a `Vec3` (or x,y,z object).
3. up - (*number*) The up vector of the "camera" as a `Vec3` (or x,y,z object).
### Examples:
Create a lookAt matrix. The eye is looking at the origin.
{% highlight js %}
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.
{% endhighlight %}
Another way of doing it with generics:
{% highlight js %}
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.
{% endhighlight %}
Mat4 Method: frustum {#Mat4:frustum}
-------------------------------------
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](http://en.wikipedia.org/wiki/Frustum).
### Syntax:
m.frustum(left, right, bottom, top, near, far);
Mat4.frustum(m, left, right, bottom, top, near, far);
### Arguments:
1. left - (*number*) The left part of the frustum.
2. right - (*number*) The right part of the frustum.
3. bottom - (*number*) The bottom part of the frustum.
4. top - (*number*) The top part of the frustum.
5. near - (*number*) The nearest part of the frustum.
6. far - (*number*) The furthest part of the frustum.
Mat4 Method: ortho {#Mat4:ortho}
-------------------------------------
Creates an orthographic projection. Modifies the current matrix.
For more information about the `orthographic projection` geometry look [here](http://en.wikipedia.org/wiki/Orthographic_projection).
### Syntax:
m.ortho(left, right, bottom, top, near, far);
Mat4.ortho(m, left, right, bottom, top, near, far);
### Arguments:
1. left - (*number*) The left part of the orthographic projection.
2. right - (*number*) The right part of the orthographic projection.
3. bottom - (*number*) The bottom part of the orthographic projection.
4. top - (*number*) The top part of the orthographic projection.
5. near - (*number*) The nearest part of the orthographic projection.
6. far - (*number*) The furthest part of the orthographic projection.
Mat4 Method: perspective {#Mat4:perspective}
---------------------------------------------
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.
### Syntax:
m.perspective(fov, aspect, near, far);
Mat4.perspective(m, fov, aspect, near, far);
### Arguments:
1. fov - (*number*) The field of view. An angle in degrees.
2. aspect - (*number*) The aspect ratio. Generally `canvas.width / canvas.height`.
3. near - (*number*) The nearest part to be captured by the camera.
4. far - (*number*) The furthest part to be captured by the camera.
Mat4 Method: toFloat32Array {#Mat4:toFloat32Array}
---------------------------------------------------
Converts the matrix in a [Float32Array](https://developer.mozilla.org/en/JavaScript_typed_arrays/Float32Array). Useful when setting matrix uniforms.
### Syntax:
m.toFloat32Array();
Mat4 Method: clone {#Mat4:clone}
------------------------------------
Clones a matrix.
### Syntax:
m.clone();
Mat4.clone(m);
Class: Quat {#Quat}
===========================
A class to handle Quaternions. More information on quternions can be
found [here](http://en.wikipedia.org/wiki/Quaternion). The quaternion
will be represented by an instance with `x`, `y`, `z`, `w` components
that make a quaternion like: `xi + yj + zk + w`.
Quat Static Method: fromVec3 {#Quat:fromVec3}
-----------------------------------------------
Create a new `Quat` instance from the `x`, `y`, `z` coordinates of a [Vec3](#Vec3) and a real component.
### Syntax:
Quat.fromVec3(v[, r]);
### Arguments:
1. v - (*object*) A `Vec3` instance.
2. r - (*number*, optional) The real component. Default's `0`.
### Examples:
Create a Quaternion from a Vec3.
{% highlight js %}
var v = new Vec3(1, 2, 3),
q = Quat.fromVec3(v, 7); //Quat(1, 2, 3, 7)
{% endhighlight %}
Quat Static Method: fromMat4 {#Quat:fromMat4}
-----------------------------------------------
Create a new `Quat` instance from a [Mat4](#Mat4). The `Mat4` instance
must be an orthogonal matrix.
### Syntax:
Quat.fromMat4(m);
### Arguments:
1. m - (*object*) A `Mat4` instance.
### Examples:
Create a Quaternion from a `Mat4`.
{% highlight js %}
var m = new Mat4(),
q = Quat.fromMat4(m); //Quat
{% endhighlight %}
Quat Static Method: fromXRotation {#Quat:fromXRotation}
--------------------------------------------------------
Create a new `Quat` instance from a rotation around the x-axis in
radians.
### Syntax:
Quat.fromXRotation(angle);
### Arguments:
1. angle - (*number*) The angle in radians.
### Examples:
Create a Quaternion from an x-axis rotation.
{% highlight js %}
var q = Quat.fromXRotation(Math.PI); //Quat(1, 0, 0, 0)
{% endhighlight %}
Quat Static Method: fromYRotation {#Quat:fromYRotation}
--------------------------------------------------------
Create a new `Quat` instance from a rotation around the y-axis in
radians.
### Syntax:
Quat.fromYRotation(angle);
### Arguments:
1. angle - (*number*) The angle in radians.
### Examples:
Create a Quaternion from an y-axis rotation.
{% highlight js %}
var q = Quat.fromYRotation(Math.PI); //Quat(0, 1, 0, 0)
{% endhighlight %}
Quat Static Method: fromZRotation {#Quat:fromZRotation}
--------------------------------------------------------
Create a new `Quat` instance from a rotation around the z-axis in
radians.
### Syntax:
Quat.fromZRotation(angle);
### Arguments:
1. angle - (*number*) The angle in radians.
### Examples:
Create a Quaternion from an z-axis rotation.
{% highlight js %}
var q = Quat.fromZRotation(Math.PI); //Quat(0, 0, 1, 0)
{% endhighlight %}
Quat Static Method: fromAxisRotation {#Quat:fromAxisRotation}
--------------------------------------------------------------
Create a new `Quat` instance from a rotation around an axis.
### Syntax:
Quat.fromAxisRotation(v, angle);
### Arguments:
1. v - (*object*) A `Vec3`-like object (i.e an array of three components).
2. angle - (*number*) The angle in radians.
### Examples:
Create a Quaternion from an z-axis rotation.
{% highlight js %}
var v = new Vec3(0, 0, 1),
q = Quat.fromAxisRotation(v, Math.PI); //Quat(0, 0, 1, 0)
{% endhighlight %}
Quat Method: constructor {#Quat:constructor}
----------------------------------------------------
Creates a new `Quat` instance.
### Syntax:
var q = new Quat(x, y, z, w);
### Arguments:
1. x - (*number*, optional) The x component. If not provided is 0.
2. y - (*number*, optional) The y component. If not provided is 0.
3. z - (*number*, optional) The z component. If not provided is 0.
4. w - (*number*, optional) The non-imaginary component. If not provided
is 0.
### Examples:
Create a (0, 0, 0, 0) quaternion.
{% highlight js %}
var q = new Quat();
{% endhighlight %}
Create a (1, 2, 3, 4) quaternion.
{% highlight js %}
var q = new Quat(1, 2, 3, 4);
{% endhighlight %}
Quat Method: setQuat {#Quat:setQuat}
------------------------------------
Set `x`, `y`, `z`, `w` coordinates of one `Quat` into another `Quat`.
### Syntax:
q1.setQuat(q2);
Quat.setQuat(q1, q2);
### Arguments:
1. q2 - (*object*) A `Quat` instance.
### Examples:
Create two quaternions and assign one quaternions components to the other one.
{% highlight js %}
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 ]
{% endhighlight %}
Set an object's `x`, `y`, `z`, `w` components to another object.
{% highlight js %}
var q1 = [],
q2 = [ 4, 5, 6, 7 ];
Quat.setQuat(q1, q2); //q1 now has [ 4, 5, 6, 7 ]
{% endhighlight %}
Quat Method: set {#Quat:set}
-------------------------------
Set `x`, `y`, `z`, `w` coordinates.
### Syntax:
q1.set(x, y, z, w);
Quat.set(q1, x, y, z, w);
### Arguments:
1. x - (*number*) The x coordinate.
2. y - (*number*) The y coordinate.
3. z - (*number*) The z coordinate.
4. w - (*number*) The w coordinate.
### Examples:
Create two quaternions and assign one quaternions components to the other one.
{% highlight js %}
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 ]
{% endhighlight %}
Set an object's `x`, `y`, `z`, `w` components to another object.
{% highlight js %}
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 ]
{% endhighlight %}
Quat Method: add {#Quat:add}
-----------------------------
Adds the `x`, `y`, `z` components of two `Quat` objects. Creates a new `Quat` instance and does not modify the original objects.
### Syntax:
q1.add(q2);
Quat.add(q1, q2);
### Arguments:
1. q2 - (*object*) A `Quat` instance.
### Examples:
Create two quaternions and add them.
{% highlight js %}
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.
{% endhighlight %}
Create two `x`, `y`, `z`, `w` objects and add them.
{% highlight js %}
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.
{% endhighlight %}
Quat Method: $add {#Quat:$add}
------------------------------------
Adds the `x`, `y`, `z`, `w` components of two `Quat` objects. Modifies the original object.
### Syntax:
q1.$add(q2);
Quat.$add(q1, q2);
### Arguments:
1. q2 - (*object*) A `Quat` instance.
### Examples:
Create two quaternions and add them.
{% highlight js %}
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).
{% endhighlight %}
Create two `x`, `y`, `z`, `w` objects and add them.
{% highlight js %}
var q1 = [ 1, 2, 3, 4 ],
q2 = [ 4, 5, 6, 7 ];
Quat.$add(q1, q2); //q1 is now [ 5, 7, 9, 11 ].
{% endhighlight %}
Quat Method: sub {#Quat:sub}
------------------------------------
Substracts the `x`, `y`, `z`, `w` components of two `Quat` objects. Creates a new `Quat` instance and does not modify the original objects.
### Syntax:
q1.sub(q2);
Quat.sub(q1, q2);
### Arguments:
1. q2 - (*object*) A `Quat` instance.
### Examples:
Create two quaternions and substract them.
{% highlight js %}
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.
{% endhighlight %}
Create two `x`, `y`, `z`, `w` objects and substract them.
{% highlight js %}
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.
{% endhighlight %}
Quat Method: $sub {#Quat:$sub}
------------------------------------
Substracts the `x`, `y`, `z`, `w` components of two `Quat` objects. Modifies the original object.
### Syntax:
q1.$sub(q2);
Quat.$sub(q1, q2);
### Arguments:
1. q2 - (*object*) A `Quat` instance.
### Examples:
Create two quaternions and substract them.
{% highlight js %}
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).
{% endhighlight %}
Create two `x`, `y`, `z`, `w` objects and add them.
{% highlight js %}
var q1 = [ 1, 2, 3, 4 ],
q2 = [ 4, 5, 6, 7 ];
Quat.$sub(q1, q2); //q1 is now [ -3, -3, -3, -3 ].
{% endhighlight %}
Quat Method: mulQuat {#Quat:mulQuat}
-------------------------------------
Multiplies two quaternions returning a new `Quat` instance with the result.
The original object is not modified.
### Syntax:
q1.mulQuat(q2);
Quat.mulQuat(q1, q2);
### Arguments:
1. q2 - (*object*) A `Quat` instance.
### Examples:
Create two Quaternions and multiply them.
{% highlight js %}
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.
{% endhighlight %}
Quat Method: $mulQuat {#Quat:$mulQuat}
---------------------------------------
Multiplies two quaternions returning and modifies the receiver with the result.
### Syntax:
q1.$mulQuat(q2);
Quat.$mulQuat(q1, q2);
### Arguments:
1. q2 - (*object*) A `Quat` instance.
### Examples:
Create two Quaternions and multiply them.
{% highlight js %}
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).
{% endhighlight %}
Quat Method: divQuat {#Quat:divQuat}
-------------------------------------
Divides two quaternions returning a new `Quat` instance with the result.
The original object is not modified.
### Syntax:
q1.divQuat(q2);
Quat.divQuat(q1, q2);
### Arguments:
1. q2 - (*object*) A `Quat` instance.
### Examples:
Create two Quaternions and divide them.
{% highlight js %}
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.
{% endhighlight %}
Quat Method: $divQuat {#Quat:$divQuat}
---------------------------------------
Divides two quaternions returning and modifies the receiver with the result.
### Syntax:
q1.$divQuat(q2);
Quat.$divQuat(q1, q2);
### Arguments:
1. q2 - (*object*) A `Quat` instance.
### Examples:
Create two Quaternions and divide them.
{% highlight js %}
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).
{% endhighlight %}
Quat Method: scale {#Quat:scale}
------------------------------------
Scales the Quat quaternion by a real number. Creates a new Quat with the scaled components.
### Syntax:
q1.scale(s);
Quat.scale(q1, s);
### Arguments:
1. s - (*number*) A real number to scale the Quat.
### Examples:
Create a quaternion and scale it by 2.
{% highlight js %}
var q1 = new Quat(1, 2, 3, 4);
q1.scale(2); //q1 is unchanged but a new Quat(2, 4, 6, 8) is created.
{% endhighlight %}
Create an `x`, `y`, `z`, `w` object and scale it by 2.
{% highlight js %}
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.
{% endhighlight %}
Quat Method: $scale {#Quat:$scale}
------------------------------------
Scales the Quat quaternion by a real number. Changes the original object.
### Syntax:
q1.$scale(s);
Quat.$scale(q1, s);
### Arguments:
1. s - (*number*) A real number to scale the Quat.
### Examples:
Create a quaternion and scale it by 2.
{% highlight js %}
var q1 = new Quat(1, 2, 3, 4);
q1.$scale(2); //q1 is now Quat(2, 4, 6, 8).
{% endhighlight %}
Create an `x`, `y`, `z`, `w` object and scale it by 2.
{% highlight js %}
var q1 = [ 1, 2, 3, 4 ];
Quat.$scale(q1, 2); //q1 is now [ 2, 4, 6, 8 ].
{% endhighlight %}
Quat Method: conjugate {#Quat:conjugate}
-----------------------------------------
Conjugates a `Quat`. Returns a new instance.
### Syntax:
q1.conjugate();
Quat.conjugate(q1);
### Examples:
Create a quaternion and conjugate it.
{% highlight js %}
var q1 = new Quat(1, 2, 3, 4);
q1.conjugate(); //q1 is unchanged but a new Quat(-1, -2, -3, 4) is created.
{% endhighlight %}
Create an `x`, `y`, `z`, `w` object and conjugate it.
{% highlight js %}
var q1 = [ 1, 2, 3, 4 ];
Quat.conjugate(q1); //q1 is still the same but a new Quat(-1, -2, -3, 4).
{% endhighlight %}
Quat Method: $conjugate {#Quat:$conjugate}
-------------------------------------------
conjugates a `Quat`. Changes the original object.
### Syntax:
q1.$conjugate();
Quat.$conjugate(q1);
### Examples:
Create a quaternion and conjugate it.
{% highlight js %}
var q1 = new Quat(1, 2, 3, 4);
q1.$conjugate(); //q1 is now Quat(-1, -2, -3, 4).
{% endhighlight %}
Create an `x`, `y`, `z`, `w` object and conjugate it.
{% highlight js %}
var q1 = [ 1, 2, 3, 4 ];
Quat.conjugate(q1); //q1 is now [ -1, -2, -3, 4 ].
{% endhighlight %}
Quat Method: neg {#Quat:neg}
------------------------------------
Negates a `Quat`. Returns a new instance.
### Syntax:
q1.neg();
Quat.neg(q1);
### Examples:
Create a quaternion and negate it.
{% highlight js %}
var q1 = new Quat(1, 2, 3, 4);
q1.neg(); //q1 is unchanged but a new Quat(-1, -2, -3, -4) is created.
{% endhighlight %}
Create an `x`, `y`, `z`, `w` object and negate it.
{% highlight js %}
var q1 = [ 1, 2, 3, 4 ];
Quat.neg(q1); //q1 is still the same but a new Quat(-1, -2, -3, -4).
{% endhighlight %}
Quat Method: $neg {#Quat:$neg}
------------------------------------
Negates a `Quat`. Changes the original object.
### Syntax:
q1.$neg();
Quat.$neg(q1);
### Examples:
Create a quaternion and negate it.
{% highlight js %}
var q1 = new Quat(1, 2, 3, 4);
q1.$neg(); //q1 is now Quat(-1, -2, -3, -4).
{% endhighlight %}
Create an `x`, `y`, `z`, `w` object and negate it.
{% highlight js %}
var q1 = [ 1, 2, 3, 4 ];
Quat.neg(q1); //q1 is now [ -1, -2, -3, -4 ].
{% endhighlight %}
Quat Method: unit {#Quat:unit}
------------------------------------
Creates a unit quaternion from the coordinates of `Quat`. The original
object is not modified.
### Syntax:
q1.unit();
Quat.unit(q1);
### Examples:
Create a quaternion and make a unit quaternion from it.
{% highlight js %}
var q1 = new Quat(1, 2, 3, 4);
q1.unit(); //q1 is unchanged but a new unit quaternion Quat is created.
{% endhighlight %}
Create an `x`, `y`, `z`, `w` object and make a unit quaternion from it.
{% highlight js %}
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.
{% endhighlight %}
Quat Method: $unit {#Quat:$unit}
------------------------------------
Creates a unit quaternion from the `Quat` coordinates. Changes the original object.
### Syntax:
q1.$unit();
Quat.$unit(q1);
### Examples:
Create a quaternion and make a unit quaternion from it.
{% highlight js %}
var q1 = new Quat(1, 2, 3, 4);
q1.$unit(); //q1 is now a unit quaternion.
{% endhighlight %}
Create an `x`, `y`, `z`, `w` object and make a unit quaternion from it.
{% highlight js %}
var q1 = [ 1, 2, 3, 4 ];
Quat.$unit(q1); //q1 is now a unit quaternion vector.
{% endhighlight %}
Quat Method: norm {#Quat:norm}
------------------------------------
Calculates the norm of `Quat`.
### Syntax:
q1.norm();
Quat.norm(q1);
### Examples:
Create a quaternion and calculate its norm.
{% highlight js %}
var q1 = new Quat(1, 2, 3, 4);
vi.norm(); //returns the real valued norm.
{% endhighlight %}
Create an `x`, `y`, `z`, `w` object and calculate its norm.
{% highlight js %}
var q1 = [ 1, 2, 3, 4 ];
//A real number with the norm is returned.
var ans = Quat.norm(q1);
{% endhighlight %}
Quat Method: normSq {#Quat:normSq}
------------------------------------
Calculates the squared norm of `Quat`.
### Syntax:
q1.normSq();
Quat.normSq(q1);
### Examples:
Create a quaternion and calculate its squared norm.
{% highlight js %}
var q1 = new Quat(1, 2, 3, 4);
vi.normSq(); //returns the real valued norm.
{% endhighlight %}
Create an `x`, `y`, `z`, `w` object and calculate its squared norm.
{% highlight js %}
var q1 = [ 1, 2, 3, 4 ];
//A real number with the squared norm is returned.
var ans = Quat.normSq(q1);
{% endhighlight %}
Quat Method: clone {#Quat:clone}
------------------------------------
Clones a quaternion.
### Syntax:
q1.clone();
Quat.clone(q1);
Reference in New Issue View Git Blame Copy Permalink