layout | title | categories | |
---|---|---|---|
docs |
Math |
|
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 class with the result of addingv1
andv2
. This operation does not modifyv1
orv2
.v1.$add(v2)
Returns the result of addingv1
tov2
, but it altersv1
updating it with the result.vResult.add2(v1, v2)
Stores the result of addingv1
tov2
invResult
, anotherVec3
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
.
New from version 1.3:
All classes now extend from Array
or some
DataView
class (i.e. some typed array). This means that Vec3
, Mat4
and Quat
-like objects are now plain arrays and not plain objects. I
have added getters 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 now an array, so vec3[0]
will also
work. The examples have been updated to reflect this.
This implementation changes the signature for some methods and probably
if you used object literals for Vec3
, Mat4
and Quat
classes these
things will have to be changed into arrays. The good thing about this is a noticeable
boost in performance everywhere in the library, and in particular in the
math functions. More information about this can be found in my
blog.
A class to handle three dimensional vectors.
Create a new Vec3
instance from the x
, y
, z
coordinates of a Quat.
PhiloGL.Vec3.fromQuat(q);
- q - (object) A
Quat
instance.
Create a vector from a Quaternion.
{% highlight js %} var q = new PhiloGL.Quat(1, 2, 3, 4), v = PhiloGL.Vec3.fromQuat(q); //Vec3(1, 2, 3) {% endhighlight %}
Creates a new Vec3
instance.
var v = new PhiloGL.Vec3(x, y, z);
- x - (number, optional) The x component. If not provided is 0.
- y - (number, optional) The y component. If not provided is 0.
- z - (number, optional) The z component. If not provided is 0.
Create a (0, 0, 0) vector.
{% highlight js %} var v = new PhiloGL.Vec3(); {% endhighlight %}
Create a (1, 2, 3) vector.
{% highlight js %} var v = new PhiloGL.Vec3(1, 2, 3); {% endhighlight %}
Set x
, y
, z
coordinates of one Vec3
into another Vec3
.
v1.setVec3(v2);
PhiloGL.Vec3.setVec3(v1, v2);
- v2 - (object) A
Vec3
instance.
Create two vectors and assign one vectors components to the other one.
{% highlight js %} var v1 = new PhiloGL.Vec3(1, 2, 3), v2 = new PhiloGL.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 ];
PhiloGL.Vec3.setVec3(v1, v2); //v1 now has [4, 5, 6] {% endhighlight %}
Set x
, y
, z
coordinates.
v1.set(x, y, z);
PhiloGL.Vec3.set(v1, x, y, z);
- x - (number) The x coordinate.
- y - (number) The y coordinate.
- z - (number) The z coordinate.
Create two vectors and assign one vectors components to the other one.
{% highlight js %} var v1 = new PhiloGL.Vec3(1, 2, 3), v2 = new PhiloGL.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 ];
PhiloGL.Vec3.set(v1, v2.x, v2.y, v2.z); //v1 now has [4, 5, 6] {% endhighlight %}
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);
PhiloGL.Vec3.add(v1, v2);
- v2 - (object) A
Vec3
instance.
Create two vectors and add them.
{% highlight js %} var v1 = new PhiloGL.Vec3(1, 2, 3), v2 = new PhiloGL.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 ];
PhiloGL.Vec3.add(v1, v2); //v1 and v2 are still the same but a new Vec3(5, 7, 9) was created. {% endhighlight %}
Adds the x
, y
, z
components of two Vec3
objects. Modifies the original object.
v1.$add(v2);
PhiloGL.Vec3.$add(v1, v2);
- v2 - (object) A
Vec3
instance.
Create two vectors and add them.
{% highlight js %} var v1 = new PhiloGL.Vec3(1, 2, 3), v2 = new PhiloGL.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 ];
PhiloGL.Vec3.$add(v1, v2); //v1 is now [ 5, 7, 9 ]. {% endhighlight %}
Adds the x
, y
, z
components of two Vec3
objects and stores the result in the receiver.
v1.add2(v2, v3);
PhiloGL.Vec3.add2(v1, v2, v3);
- v2 - (object) A
Vec3
instance. - v3 - (object) A
Vec3
instance.
Create two vectors and add them.
{% highlight js %} var v1 = new PhiloGL.Vec3(), v2 = new PhiloGL.Vec3(1, 2, 3), v3 = new PhiloGL.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 ];
PhiloGL.Vec3.add2(v1, v2, v3); //v2 and v3 are still the same but v1 is [ 5, 7, 9 ]. {% endhighlight %}
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);
PhiloGL.Vec3.sub(v1, v2);
- v2 - (object) A
Vec3
instance.
Create two vectors and substract them.
{% highlight js %} var v1 = new PhiloGL.Vec3(1, 2, 3), v2 = new PhiloGL.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 ];
PhiloGL.Vec3.sub(v1, v2); //v1 and v2 are still the same but a new Vec3(-3, -3, -3) was created. {% endhighlight %}
Substracts the x
, y
, z
components of two Vec3
objects. Modifies the original object.
v1.$sub(v2);
PhiloGL.Vec3.$sub(v1, v2);
- v2 - (object) A
Vec3
instance.
Create two vectors and substract them.
{% highlight js %} var v1 = new PhiloGL.Vec3(1, 2, 3), v2 = new PhiloGL.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 ];
PhiloGL.Vec3.$sub(v1, v2); //v1 is now [ -3, -3, -3 ]. {% endhighlight %}
Substracts the x
, y
, z
components of two Vec3
objects and stores the result in the receiver.
v1.sub2(v2, v3);
PhiloGL.Vec3.sub2(v1, v2, v3);
- v2 - (object) A
Vec3
instance. - v3 - (object) A
Vec3
instance.
Create two vectors and substract them.
{% highlight js %} var v1 = new PhiloGL.Vec3(), v2 = new PhiloGL.Vec3(1, 2, 3), v3 = new PhiloGL.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 ];
PhiloGL.Vec3.sub2(v1, v2, v3); //v2 and v3 are still the same but v1 is { x: -3, y: -3, z: -3 }. {% endhighlight %}
Scales the Vec3 vector by a real number. Creates a new Vec3 with the scaled components.
v1.scale(s);
PhiloGL.Vec3.scale(v1, s);
- s - (number) A real number to scale the Vec3.
Create a vector and scale it by 2.
{% highlight js %} var v1 = new PhiloGL.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 ];
PhiloGL.Vec3.scale(v1, 2); //v1 is still the same but a new Vec3(2, 4, 6) was created. {% endhighlight %}
Scales the Vec3 vector by a real number. Changes the original object.
v1.$scale(s);
PhiloGL.Vec3.$scale(v1, s);
- s - (number) A real number to scale the Vec3.
Create a vector and scale it by 2.
{% highlight js %} var v1 = new PhiloGL.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 ];
PhiloGL.Vec3.$scale(v1, 2); //v1 is now [ 2, 4, 6 ]. {% endhighlight %}
Negates a Vec3
. Returns a new instance.
v1.neg();
PhiloGL.Vec3.neg(v1);
Create a vector and negate it.
{% highlight js %} var v1 = new PhiloGL.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 ];
PhiloGL.Vec3.neg(v1); //v1 is still the same but a new Vec3(-1, -2, -3). {% endhighlight %}
Negates a Vec3
. Changes the original object.
v1.$neg();
PhiloGL.Vec3.$neg(v1);
Create a vector and negate it.
{% highlight js %} var v1 = new PhiloGL.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 ];
PhiloGL.Vec3.neg(v1); //v1 is now [ -1, -2, -3 ]. {% endhighlight %}
Creates a unit vector from the coordinates of Vec3
.
v1.unit();
PhiloGL.Vec3.unit(v1);
Create a vector and make a unit vector from it.
{% highlight js %} var v1 = new PhiloGL.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 ];
PhiloGL.Vec3.unit(v1); //v1 is still the same but a new Vec3 that is a unit vector is created. {% endhighlight %}
Creates a unit vector from the Vec3
coordinates. Changes the original object.
v1.$unit();
PhiloGL.Vec3.$unit(v1);
Create a vector and make a unit vector from it.
{% highlight js %} var v1 = new PhiloGL.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 ];
PhiloGL.Vec3.$unit(v1); //v1 is now a unit vector object. {% endhighlight %}
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);
PhiloGL.Vec3.cross(v1, v2);
- v2 - (object) A
Vec3
instance.
Create two vectors and make a cross product.
{% highlight js %} var v1 = new PhiloGL.Vec3(1, 2, 3), v2 = new PhiloGL.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 = PhiloGL.Vec3.cross(v1, v2); {% endhighlight %}
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);
PhiloGL.Vec3.$cross(v1, v2);
- v2 - (object) A
Vec3
instance.
Create two vectors and make a cross product.
{% highlight js %} var v1 = new PhiloGL.Vec3(1, 2, 3), v2 = new PhiloGL.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 = PhiloGL.Vec3.$cross(v1, v2); {% endhighlight %}
Calculates the distance between two Vec3
.
v1.distTo(v2);
PhiloGL.Vec3.distTo(v1, v2);
- v2 - (object) A
Vec3
instance.
Create two vectors and calculate the distance.
{% highlight js %} var v1 = new PhiloGL.Vec3(1, 2, 3), v2 = new PhiloGL.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 = PhiloGL.Vec3.distTo(v1, v2); {% endhighlight %}
Calculates the squared distance between two Vec3
.
v1.distToSq(v2);
PhiloGL.Vec3.distToSq(v1, v2);
- v2 - (object) A
Vec3
instance.
Create two vectors and calculate the squared distance.
{% highlight js %} var v1 = new PhiloGL.Vec3(1, 2, 3), v2 = new PhiloGL.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 = PhiloGL.Vec3.distToSq(v1, v2); {% endhighlight %}
Calculates the norm of Vec3
.
v1.norm();
PhiloGL.Vec3.norm(v1);
Create a vector and calculate its norm.
{% highlight js %} var v1 = new PhiloGL.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 = PhiloGL.Vec3.norm(v1); {% endhighlight %}
Calculates the squared norm of Vec3
.
v1.normSq();
PhiloGL.Vec3.normSq(v1);
Create a vector and calculate its squared norm.
{% highlight js %} var v1 = new PhiloGL.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 = PhiloGL.Vec3.normSq(v1); {% endhighlight %}
Calculates the dot product between two Vec3
. You can find more information about the
dot product here.
v1.dot(v2);
PhiloGL.Vec3.dot(v1, v2);
- v2 - (object) A
Vec3
instance.
Create two vectors and calculate the dot product.
{% highlight js %} var v1 = new PhiloGL.Vec3(1, 2, 3), v2 = new PhiloGL.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 = PhiloGL.Vec3.dot(v1, v2); {% endhighlight %}
Clones a vector.
v1.clone();
PhiloGL.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.
PhiloGL.Mat4.fromQuat(q);
- q - (object) A
Quat
instance.
Create a matrix from a Quaternion.
{% highlight js %} var q = new PhiloGL.Quat(1, 2, 3, 4).$unit(), m = PhiloGL.Mat4.fromQuat(q); //a new Mat4 instance {% endhighlight %}
Creates a new Mat4
instance. If no arguments are set then an Identity matrix is created.
var m = new PhiloGL.Mat4();
var m = new PhiloGL.Mat4(n11, n12, n13, n14,
n21, n22, n23, n24,
n31, n32, n33, n34,
n41, n42, n43, n44);
- n - (number) The matrix component.
Create an identity matrix.
{% highlight js %} var m = new PhiloGL.Mat4(); {% endhighlight %}
Create a null matrix.
{% highlight js %} var m = new PhiloGL.Mat4( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ); {% endhighlight %}
Modifies the matrix to be an Identity matrix.
m.id();
PhiloGL.Mat4.id(m);
Create an identity matrix from some random matrix.
{% highlight js %} var m = new PhiloGL.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 = [];
PhiloGL.Mat4.id(m); //m object components are the Identity matrix ones. {% endhighlight %}
Set all matrix coordinates.
m.set(n11, n12, n13, n14,
n21, n22, n23, n24,
n31, n32, n33, n34,
n41, n42, n43, n44);
PhiloGL.Mat4.set(m, n11, n12, n13, n14,
n21, n22, n23, n24,
n31, n32, n33, n34,
n41, n42, n43, n44);
- n - (number) The n matrix coordinates.
Create a matrix and set some values to it.
{% highlight js %} var m = new PhiloGL.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 = [];
PhiloGL.Mat4.set(m, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4);
{% endhighlight %}
Multiplies a Mat4
by a Vec3
. Returns a new Vec3
without modifying the passed in object.
m.mulVec3(v);
PhiloGL.Mat4.mulVec3(m, v);
- v - (object) A
Vec3
instance.
Create a matrix and a vector and multiply them.
{% highlight js %} var m = new PhiloGL.Mat4(), v = new PhiloGL.Vec3(1, 1, 1);
m.mulVec3(v); {% endhighlight %}
Create a matrix object and a vector object and multiply them.
{% highlight js %} var m = [], v = [];
PhiloGL.Mat4.id(m); PhiloGL.Vec3.set(v, 1, 1, 1);
PhiloGL.Mat4.mulVec3(m, v); {% endhighlight %}
Multiplies a Mat4
by a Vec3
. Modifies the receiver.
m.$mulVec3(v);
PhiloGL.Mat4.$mulVec3(m, v);
- v - (object) A
Vec3
instance.
Create a matrix and a vector and multiply them.
{% highlight js %} var m = new PhiloGL.Mat4(), v = new PhiloGL.Vec3(1, 1, 1);
m.$mulVec3(v); {% endhighlight %}
Create a matrix object and a vector object and multiply them.
{% highlight js %} var m = [], v = [];
PhiloGL.Mat4.id(m); PhiloGL.Vec3.set(v, 1, 1, 1);
PhiloGL.Mat4.$mulVec3(m, v); {% endhighlight %}
Multiplies two Mat4
. Creates a new Mat4
with the result and does not modify the original instances.
m.mulMat4(m1);
PhiloGL.Mat4.mulMat4(m, m1);
- m1 - (object) A
Mat4
instance.
Create two matrices and multiply them.
{% highlight js %} var m = new PhiloGL.Mat4(), m1 = new PhiloGL.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 = [];
PhiloGL.Mat4.id(m); PhiloGL.Mat4.id(m1); PhiloGL.Mat4.mulMat4(m, m1); {% endhighlight %}
Multiplies two Mat4
, storing the result in the receiver.
m.$mulMat4(m1);
PhiloGL.Mat4.$mulMat4(m, m1);
- m1 - (object) A
Mat4
instance.
Create two matrices and multiply them.
{% highlight js %} var m = new PhiloGL.Mat4(), m1 = new PhiloGL.Mat4();
m.$mulMat4(m1); //the result is stored in m. {% endhighlight %}
Create a two matrices objects and multiply them.
{% highlight js %} var m = [], m1 = [];
PhiloGL.Mat4.id(m); PhiloGL.Mat4.id(m1); PhiloGL.Mat4.$mulMat4(m, m1); {% endhighlight %}
Multiplies two Mat4
, storing the result in the receiver.
m.mulMat42(m1, m2);
PhiloGL.Mat4.mulMat42(m, m1, m2);
- m1 - (object) A
Mat4
instance. - m2 - (object) A
Mat4
instance.
Create two matrices and multiply them.
{% highlight js %} var m = new PhiloGL.Mat4(), m1 = new PhiloGL.Mat4(), m2 = new PhiloGL.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 = [];
PhiloGL.Mat4.id(m1); PhiloGL.Mat4.id(m2); PhiloGL.Mat4.mulMat42(m, m1, m2); {% endhighlight %}
Adds two Mat4
. Creates a new Mat4
with the result and does not modify the original instances.
m.add(m1);
PhiloGL.Mat4.add(m, m1);
- m1 - (object) A
Mat4
instance.
Create two matrices and add them.
{% highlight js %} var m = new PhiloGL.Mat4(), m1 = new PhiloGL.Mat4();
m.add(m1); //the result is a new matrix {% endhighlight %}
Create a two matrices objects and add them.
{% highlight js %} var m = [], m1 = [];
PhiloGL.Mat4.id(m); PhiloGL.Mat4.id(m1); PhiloGL.Mat4.add(m, m1); {% endhighlight %}
Adds two Mat4
, storing the result in the receiver.
m.$add(m1);
PhiloGL.Mat4.$add(m, m1);
- m1 - (object) A
Mat4
instance.
Create two matrices and add them.
{% highlight js %} var m = new PhiloGL.Mat4(), m1 = new PhiloGL.Mat4();
m.$add(m1); //the result is stored in m. {% endhighlight %}
Create a two matrices objects and add them.
{% highlight js %} var m = [], m1 = [];
PhiloGL.Mat4.id(m); PhiloGL.Mat4.id(m1); PhiloGL.Mat4.$add(m, m1); {% endhighlight %}
Transposes a Mat4
matrix. More info about this operation can be found here.
Creates a new Mat4
with the result.
m.transpose();
PhiloGL.Mat4.transpose(m);
Create a Mat4
matrix and transpose it.
{% highlight js %} var m = new PhiloGL.Mat4();
m.transpose(); //the result is a new Identity matrix {% endhighlight %}
Transposes a Mat4
matrix. More info about this operation can be found here.
Modifies the current matrix.
m.$transpose();
PhiloGL.Mat4.$transpose(m);
Create a Mat4
matrix and transpose it.
{% highlight js %} var m = new PhiloGL.Mat4();
m.$transpose(); //the result is stored in m {% endhighlight %}
Applies a rotation of theta
by vec
to a Mat4
matrix returning the result in a new matrix.
m.rotateAxis(theta, vec);
PhiloGL.Mat4.rotateAxis(m, theta, vec);
- theta - (number) An angle in radians.
- vec - (object) A
Vec3
(or array).
Create a rotation by theta
and v
.
{% highlight js %} var m = new PhiloGL.Mat4(), v = new PhiloGL.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 PhiloGL.Mat4(), v = [ 1, 1, 1 ];
m.rotateAxis(Math.PI, v); //the result is a new matrix {% endhighlight %}
Applies a rotation of angle theta
by vector vec
to a Mat4
altering the current matrix.
m.$rotateAxis(theta, vec);
PhiloGL.Mat4.$rotateAxis(m, theta, vec);
- theta - (number) An angle in radians.
- vec - (object) A
Vec3
(or array).
Create a rotation by theta
and v
.
{% highlight js %} var m = new PhiloGL.Mat4(), v = new PhiloGL.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 PhiloGL.Mat4(), v = [ 1, 1, 1 ];
m.$rotateAxis(Math.PI, v); //the result is in m {% endhighlight %}
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.
m.rotateXYZ(rx, ry, rz);
PhiloGL.Mat4.rotateXYZ(m, rx, ry, rz);
- rx - (number) An angle in radians.
- ry - (number) An angle in radians.
- rz - (number) An angle in radians.
Create a rotation on the x-axis.
{% highlight js %} var m = new PhiloGL.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 = [];
PhiloGL.Mat4.id(m); PhiloGL.Mat4.rotateXYZ(m, Math.PI, 0, 0); //creates a new Mat4 with the result. {% endhighlight %}
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);
PhiloGL.Mat4.$rotateXYZ(m, rx, ry, rz);
- rx - (number) An angle in radians.
- ry - (number) An angle in radians.
- rz - (number) An angle in radians.
Create a rotation on the x-axis.
{% highlight js %} var m = new PhiloGL.Mat4();
m.$rotateXYZ(Math.PI, 0, 0); //alters m {% endhighlight %}
Another way of doing it with generics:
{% highlight js %} var m = [];
PhiloGL.Mat4.id(m); PhiloGL.Mat4.$rotateXYZ(m, Math.PI, 0, 0); //alters m {% endhighlight %}
Applies a translation to Mat4
in the directions x
, y
and z
.
Stores the result in a new Mat4
instance.
m.translate(x, y, z);
PhiloGL.Mat4.translate(m, x, y, z);
- x - (number) The amount to be translated in the x direction.
- y - (number) The amount to be translated in the y direction.
- z - (number) The amount to be translated in the z direction..
Create a translation on the x-axis.
{% highlight js %} var m = new PhiloGL.Mat4();
m.translate(10, 0, 0); //the result is a new matrix {% endhighlight %}
Another way of doing it with generics:
{% highlight js %} var m = [];
PhiloGL.Mat4.id(m); PhiloGL.Mat4.translate(m, 10, 0, 0); //creates a new Mat4 with the result. {% endhighlight %}
Applies a translation to Mat4
in the directions x
, y
and z
.
Alters the original matrix.
m.$translate(x, y, z);
PhiloGL.Mat4.$translate(m, x, y, z);
- x - (number) The amount to be translated in the x direction.
- y - (number) The amount to be translated in the y direction.
- z - (number) The amount to be translated in the z direction..
Create a translation on the x-axis.
{% highlight js %} var m = new PhiloGL.Mat4();
m.$translate(10, 0, 0); //the result is in m {% endhighlight %}
Another way of doing it with generics:
{% highlight js %} var m = [];
PhiloGL.Mat4.id(m); PhiloGL.Mat4.$translate(m, 10, 0, 0); //the result is in m {% endhighlight %}
Applies scaling to Mat4
in the directions x
, y
and z
.
Stores the result in a new Mat4
instance.
m.scale(x, y, z);
PhiloGL.Mat4.scale(m, x, y, z);
- x - (number) The amount to be scaled in the x direction.
- y - (number) The amount to be scaled in the y direction.
- z - (number) The amount to be scaled in the z direction..
Create a scaling on the x-axis.
{% highlight js %} var m = new PhiloGL.Mat4();
m.scale(10, 0, 0); //the result is a new matrix {% endhighlight %}
Another way of doing it with generics:
{% highlight js %} var m = [];
PhiloGL.Mat4.id(m); PhiloGL.Mat4.scale(m, 10, 0, 0); //creates a new Mat4 with the result. {% endhighlight %}
Applies scaling to Mat4
in the directions x
, y
and z
.
Alters the original matrix.
m.$scale(x, y, z);
PhiloGL.Mat4.$scale(m, x, y, z);
- x - (number) The amount to be scaled in the x direction.
- y - (number) The amount to be scaled in the y direction.
- z - (number) The amount to be scaled in the z direction..
Create a scaling on the x-axis.
{% highlight js %} var m = new PhiloGL.Mat4();
m.$scale(10, 0, 0); //the result is in m {% endhighlight %}
Another way of doing it with generics:
{% highlight js %} var m = [];
PhiloGL.Mat4.id(m); PhiloGL.Mat4.$scale(m, 10, 0, 0); //the result is in m {% endhighlight %}
Inverts a Mat4
matrix. The matrix has to be invertible.
Creates a new Mat4
with the result.
m.invert();
PhiloGL.Mat4.invert(m);
Create a Mat4
matrix and invert it.
{% highlight js %} var m = new PhiloGL.Mat4();
m.invert(); //the result is a new matrix {% endhighlight %}
Inverts a Mat4
matrix. The matrix has to be invertible.
Modifies the current matrix.
m.$invert();
PhiloGL.Mat4.$invert(m);
Create a Mat4
matrix and invert it.
{% highlight js %} var m = new PhiloGL.Mat4();
m.$invert(); //the result is stored in m {% endhighlight %}
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.
m.lookAt(eye, center, up);
PhiloGL.Mat4.lookAt(m, eye, center, up);
- eye - (object) The eye position as a
Vec3
(or x,y,z object). - center - (number) The center position as a
Vec3
(or x,y,z object). - up - (number) The up vector of the "camera" as a
Vec3
(or x,y,z object).
Create a lookAt matrix. The eye is looking at the origin.
{% highlight js %} var m = new PhiloGL.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 ];
PhiloGL.Mat4.lookAt(m, eye, center, up); //the original object is modified. {% endhighlight %}
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);
PhiloGL.Mat4.frustum(m, left, right, bottom, top, near, far);
- left - (number) The left part of the frustum.
- right - (number) The right part of the frustum.
- bottom - (number) The bottom part of the frustum.
- top - (number) The top part of the frustum.
- near - (number) The nearest part of the frustum.
- far - (number) The furthest part of the frustum.
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);
PhiloGL.Mat4.ortho(m, left, right, bottom, top, near, far);
- left - (number) The left part of the orthographic projection.
- right - (number) The right part of the orthographic projection.
- bottom - (number) The bottom part of the orthographic projection.
- top - (number) The top part of the orthographic projection.
- near - (number) The nearest part of the orthographic projection.
- far - (number) The furthest part of the orthographic projection.
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);
PhiloGL.Mat4.perspective(m, fov, aspect, near, far);
- fov - (number) The field of view. An angle in degrees.
- aspect - (number) The aspect ratio. Generally
canvas.width / canvas.height
. - near - (number) The nearest part to be captured by the camera.
- far - (number) The furthest part to be captured by the camera.
Converts the matrix in a Float32Array. Useful when setting matrix uniforms.
m.toFloat32Array();
Clones a matrix.
m.clone();
PhiloGL.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.
PhiloGL.Quat.fromVec3(v[, r]);
- v - (object) A
Vec3
instance. - r - (number, optional) The real component. Default's
0
.
Create a Quaternion from a Vec3.
{% highlight js %} var v = new PhiloGL.Vec3(1, 2, 3), q = PhiloGL.Quat.fromVec3(v, 7); //Quat(1, 2, 3, 7) {% endhighlight %}
Create a new Quat
instance from a Mat4. The Mat4
instance
must be an orthogonal matrix.
PhiloGL.Quat.fromMat4(m);
- m - (object) A
Mat4
instance.
Create a Quaternion from a Mat4
.
{% highlight js %} var m = new PhiloGL.Mat4(), q = PhiloGL.Quat.fromMat4(m); //Quat {% endhighlight %}
Create a new Quat
instance from a rotation around the x-axis in
radians.
PhiloGL.Quat.fromXRotation(angle);
- angle - (number) The angle in radians.
Create a Quaternion from an x-axis rotation.
{% highlight js %} var q = PhiloGL.Quat.fromXRotation(Math.PI); //Quat(1, 0, 0, 0) {% endhighlight %}
Create a new Quat
instance from a rotation around the y-axis in
radians.
PhiloGL.Quat.fromYRotation(angle);
- angle - (number) The angle in radians.
Create a Quaternion from an y-axis rotation.
{% highlight js %} var q = PhiloGL.Quat.fromYRotation(Math.PI); //Quat(0, 1, 0, 0) {% endhighlight %}
Create a new Quat
instance from a rotation around the z-axis in
radians.
PhiloGL.Quat.fromZRotation(angle);
- angle - (number) The angle in radians.
Create a Quaternion from an z-axis rotation.
{% highlight js %} var q = PhiloGL.Quat.fromZRotation(Math.PI); //Quat(0, 0, 1, 0) {% endhighlight %}
Create a new Quat
instance from a rotation around an axis.
PhiloGL.Quat.fromAxisRotation(v, angle);
- v - (object) A
Vec3
-like object (i.e an array of three components). - angle - (number) The angle in radians.
Create a Quaternion from an z-axis rotation.
{% highlight js %} var v = new PhiloGL.Vec3(0, 0, 1), q = PhiloGL.Quat.fromAxisRotation(v, Math.PI); //Quat(0, 0, 1, 0) {% endhighlight %}
Creates a new Quat
instance.
var q = new PhiloGL.Quat(x, y, z, w);
- x - (number, optional) The x component. If not provided is 0.
- y - (number, optional) The y component. If not provided is 0.
- z - (number, optional) The z component. If not provided is 0.
- w - (number, optional) The non-imaginary component. If not provided is 0.
Create a (0, 0, 0, 0) quaternion.
{% highlight js %} var q = new PhiloGL.Quat(); {% endhighlight %}
Create a (1, 2, 3, 4) quaternion.
{% highlight js %} var q = new PhiloGL.Quat(1, 2, 3, 4); {% endhighlight %}
Set x
, y
, z
, w
coordinates of one Quat
into another Quat
.
q1.setQuat(q2);
PhiloGL.Quat.setQuat(q1, q2);
- q2 - (object) A
Quat
instance.
Create two quaternions and assign one quaternions components to the other one.
{% highlight js %} var q1 = new PhiloGL.Quat(1, 2, 3, 4), q2 = new PhiloGL.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 ];
PhiloGL.Quat.setQuat(q1, q2); //q1 now has [ 4, 5, 6, 7 ] {% endhighlight %}
Set x
, y
, z
, w
coordinates.
q1.set(x, y, z, w);
PhiloGL.Quat.set(q1, x, y, z, w);
- x - (number) The x coordinate.
- y - (number) The y coordinate.
- z - (number) The z coordinate.
- w - (number) The w coordinate.
Create two quaternions and assign one quaternions components to the other one.
{% highlight js %} var q1 = new PhiloGL.Quat(1, 2, 3, 4), q2 = new PhiloGL.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 ];
PhiloGL.Quat.set(q1, q2.x, q2.y, q2.z, q2.w); //q1 now has [ 4, 5, 6, 7 ] {% endhighlight %}
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);
PhiloGL.Quat.add(q1, q2);
- q2 - (object) A
Quat
instance.
Create two quaternions and add them.
{% highlight js %} var q1 = new PhiloGL.Quat(1, 2, 3, 4), q2 = new PhiloGL.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 ];
PhiloGL.Quat.add(q1, q2); //q1 and q2 are still the same but a new Quat(5, 7, 9, 11) was created. {% endhighlight %}
Adds the x
, y
, z
, w
components of two Quat
objects. Modifies the original object.
q1.$add(q2);
PhiloGL.Quat.$add(q1, q2);
- q2 - (object) A
Quat
instance.
Create two quaternions and add them.
{% highlight js %} var q1 = new PhiloGL.Quat(1, 2, 3, 4), q2 = new PhiloGL.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 ];
PhiloGL.Quat.$add(q1, q2); //q1 is now [ 5, 7, 9, 11 ]. {% endhighlight %}
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);
PhiloGL.Quat.sub(q1, q2);
- q2 - (object) A
Quat
instance.
Create two quaternions and substract them.
{% highlight js %} var q1 = new PhiloGL.Quat(1, 2, 3, 4), q2 = new PhiloGL.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 ];
PhiloGL.Quat.sub(q1, q2); //q1 and q2 are still the same but a new Quat(-3, -3, -3, -3) was created. {% endhighlight %}
Substracts the x
, y
, z
, w
components of two Quat
objects. Modifies the original object.
q1.$sub(q2);
PhiloGL.Quat.$sub(q1, q2);
- q2 - (object) A
Quat
instance.
Create two quaternions and substract them.
{% highlight js %} var q1 = new PhiloGL.Quat(1, 2, 3, 4), q2 = new PhiloGL.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 ];
PhiloGL.Quat.$sub(q1, q2); //q1 is now [ -3, -3, -3, -3 ]. {% endhighlight %}
Multiplies two quaternions returning a new Quat
instance with the result.
The original object is not modified.
q1.mulQuat(q2);
PhiloGL.Quat.mulQuat(q1, q2);
- q2 - (object) A
Quat
instance.
Create two Quaternions and multiply them.
{% highlight js %} var q1 = new PhiloGL.Quat(1, 0, 0, 0), q2 = new PhiloGL.Quat(1, 0, 0, 0);
q1.mulQuat(q2); //q1 is unchanged but a new Quat(-1, 0, 0, 0) is created. {% endhighlight %}
Multiplies two quaternions returning and modifies the receiver with the result.
q1.$mulQuat(q2);
PhiloGL.Quat.$mulQuat(q1, q2);
- q2 - (object) A
Quat
instance.
Create two Quaternions and multiply them.
{% highlight js %} var q1 = new PhiloGL.Quat(1, 0, 0, 0), q2 = new PhiloGL.Quat(1, 0, 0, 0);
q1.$mulQuat(q2); //q1 is now Quat(-1, 0, 0, 0). {% endhighlight %}
Divides two quaternions returning a new Quat
instance with the result.
The original object is not modified.
q1.divQuat(q2);
PhiloGL.Quat.divQuat(q1, q2);
- q2 - (object) A
Quat
instance.
Create two Quaternions and divide them.
{% highlight js %} var q1 = new PhiloGL.Quat(1, 0, 0, 0), q2 = new PhiloGL.Quat(1, 0, 0, 0);
q1.divQuat(q2); //q1 is unchanged but a new Quat(1, 0, 0, 0) is created. {% endhighlight %}
Divides two quaternions returning and modifies the receiver with the result.
q1.$divQuat(q2);
PhiloGL.Quat.$divQuat(q1, q2);
- q2 - (object) A
Quat
instance.
Create two Quaternions and divide them.
{% highlight js %} var q1 = new PhiloGL.Quat(1, 0, 0, 0), q2 = new PhiloGL.Quat(1, 0, 0, 0);
q1.$divQuat(q2); //q1 is now Quat(1, 0, 0, 0). {% endhighlight %}
Scales the Quat quaternion by a real number. Creates a new Quat with the scaled components.
q1.scale(s);
PhiloGL.Quat.scale(q1, s);
- s - (number) A real number to scale the Quat.
Create a quaternion and scale it by 2.
{% highlight js %} var q1 = new PhiloGL.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 ];
PhiloGL.Quat.scale(q1, 2); //q1 is still the same but a new Quat(2, 4, 6, 8) was created. {% endhighlight %}
Scales the Quat quaternion by a real number. Changes the original object.
q1.$scale(s);
PhiloGL.Quat.$scale(q1, s);
- s - (number) A real number to scale the Quat.
Create a quaternion and scale it by 2.
{% highlight js %} var q1 = new PhiloGL.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 ];
PhiloGL.Quat.$scale(q1, 2); //q1 is now [ 2, 4, 6, 8 ]. {% endhighlight %}
Conjugates a Quat
. Returns a new instance.
q1.conjugate();
PhiloGL.Quat.conjugate(q1);
Create a quaternion and conjugate it.
{% highlight js %} var q1 = new PhiloGL.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 ];
PhiloGL.Quat.conjugate(q1); //q1 is still the same but a new Quat(-1, -2, -3, 4). {% endhighlight %}
conjugates a Quat
. Changes the original object.
q1.$conjugate();
PhiloGL.Quat.$conjugate(q1);
Create a quaternion and conjugate it.
{% highlight js %} var q1 = new PhiloGL.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 ];
PhiloGL.Quat.conjugate(q1); //q1 is now [ -1, -2, -3, 4 ]. {% endhighlight %}
Negates a Quat
. Returns a new instance.
q1.neg();
PhiloGL.Quat.neg(q1);
Create a quaternion and negate it.
{% highlight js %} var q1 = new PhiloGL.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 ];
PhiloGL.Quat.neg(q1); //q1 is still the same but a new Quat(-1, -2, -3, -4). {% endhighlight %}
Negates a Quat
. Changes the original object.
q1.$neg();
PhiloGL.Quat.$neg(q1);
Create a quaternion and negate it.
{% highlight js %} var q1 = new PhiloGL.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 ];
PhiloGL.Quat.neg(q1); //q1 is now [ -1, -2, -3, -4 ]. {% endhighlight %}
Creates a unit quaternion from the coordinates of Quat
. The original
object is not modified.
q1.unit();
PhiloGL.Quat.unit(q1);
Create a quaternion and make a unit quaternion from it.
{% highlight js %} var q1 = new PhiloGL.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 ];
PhiloGL.Quat.unit(q1); //q1 is still the same but a new Quat that is a unit quaternion is created. {% endhighlight %}
Creates a unit quaternion from the Quat
coordinates. Changes the original object.
q1.$unit();
PhiloGL.Quat.$unit(q1);
Create a quaternion and make a unit quaternion from it.
{% highlight js %} var q1 = new PhiloGL.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 ];
PhiloGL.Quat.$unit(q1); //q1 is now a unit quaternion vector. {% endhighlight %}
Calculates the norm of Quat
.
q1.norm();
PhiloGL.Quat.norm(q1);
Create a quaternion and calculate its norm.
{% highlight js %} var q1 = new PhiloGL.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 = PhiloGL.Quat.norm(q1); {% endhighlight %}
Calculates the squared norm of Quat
.
q1.normSq();
PhiloGL.Quat.normSq(q1);
Create a quaternion and calculate its squared norm.
{% highlight js %} var q1 = new PhiloGL.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 = PhiloGL.Quat.normSq(q1); {% endhighlight %}
Clones a quaternion.
q1.clone();
PhiloGL.Quat.clone(q1);