{ x, y, z, w }

Static variables

staticeuler:Quaternion

input/output euler as rotation angles around x, y, z axis ( as faux Quaternion ), but set /gets internally as the Quaternion value

staticmagnitude:Float

staticread onlyunit:Quaternion


>>> Quaternion.unit == new Quaternion({ x: 1., y: 1., z: 1., w: 1. })

staticread onlyunitNormal:Quaternion


>>> ({ 
... var q = new Quaternion( { x: 1., y: 1., z: 1., w: 1. } );
... Quaternion.unitNormal == q.normalize();
... }) == true

staticread onlyzero:Quaternion


>>> Quaternion.zero == new Quaternion({ x: 0., y: 0., z: 0., w: 0. })

staticread onlyzeroNormal:Quaternion


>>> Quaternion.zeroNormal == new Quaternion({ x: 0., y: 0., z: 0., w: 1. })

Static methods

@:op(A + B)staticinlineadd(a:Quaternion, b:Quaternion):Quaternion


>>> ({ 
... var a = Quaternion.unit;
... a + a == new Quaternion({ x: 2., y: 2., z: 2., w: 2. }); 
... }) == true

staticinlineclone(this:Mat1x4):Quaternion

@:op(~A)staticinlineconjugate(a:Quaternion):Quaternion


>>> ({ 
... var a = new Quaternion({ x: 1., y: 2., z: 3., w: 1. });
... var b = ~a;
... b == new Quaternion({ x: -1., y: -2., z: -3., w: 1. }); }) == true

staticinlinecopy(pin:Quaternion, pout:Quaternion):Quaternion


>>> ({ 
... var a = new Quaternion({ x: 1., y: 2., z: 3., w: 1. });
... var b = Quaternion.zero;
... var c = Quaternion.copy( a, b ); 
... a == c; }) == true

staticinlinecreateFromAxisAngle(x:Float, y:Float, z:Float, theta:Float):Quaternion

staticinlinecross(this:Mat1x4, v:Quaternion):Quaternion

staticinlinedistanceZeroOne(this:Mat1x4, q:Quaternion):Float

provides a distance measure between Quaternions between 1 ( Math.PI ) and 0 ( 0 );

@:op(A / B)staticinlinedivide(a:Quaternion, v:Float):Quaternion

@:op(A / B)staticinlinedivide2(v:Float, a:Quaternion):Quaternion

staticinlinedot(this:Mat1x4):Float

staticinlinedotProd(this:Mat1x4, b:Quaternion):Float

staticinlinedotProduct(a:Quaternion, b:Quaternion):Float

@:op(A == B)staticinlineequal(a:Quaternion, b:Quaternion):Bool


>>> ({ 
... var a = new Quaternion({ x: 1., y: 2., z: 3., w: 1. });
... var b = new Quaternion({ x: 1., y: 2., z: 3., w: 1. });
... a == b; }) == true

@:fromstaticinlinefromArray(arr:Array<Float>):Quaternion


>>> ({ 
... var a = Quaternion.unit;
... var b: Quaternion = [ 1., 1., 1., 1. ];
... Equal.equals( a, b ); }) == true

staticinlinefromAxisAngle(theta:Float, axis:Quaternion):Quaternion

@:fromstaticinlinefromMatrix3x3(m:Matrix3x3):Quaternion

@:fromstaticinlinefromMatrix4x3(m4x3:Matrix4x3):Quaternion

@:fromstaticinlinefromVec(vec:Vector<Float>):Quaternion


>>> ({ 
... var a = Quaternion.unit;
... var b = haxe.ds.Vector.fromArrayCopy([ 1., 1., 1., 1. ]);
... var c: Quaternion = b;
... a == b; }) == true

staticinlinefromYawPitchRoll(yaw:Float, pitch:Float, roll:Float):Quaternion

used to set yaw pitch and roll ( very similar to set euler ) but static.

 *     x:  Pitch
 *     y:  Yaw
 *     z:  Roll

staticinlinegetAngleAxis(this:Mat1x4):{axis:Matrix1x3, angle:Float}

staticinlineidentity(out:Quaternion):Quaternion


>>> ({ 
... var a = Quaternion.identity( Quaternion.zero );
... var b = Quaternion.zeroNormal;
... a == b; }) == true

staticinlineinvert(this:Mat1x4):Quaternion

staticinlinelerp(a:Quaternion, b:Quaternion, t:Float):Quaternion

staticlookAt(this:Mat1x4, target:Matrix1x4, current:Matrix1x4, eye:Matrix1x4, up:Matrix1x4):Quaternion

staticinlinemagnitudeSquared(this:Mat1x4):Float

@:op(A * B)staticinlinemultiplyQ(q1:Quaternion, q2:Quaternion):Quaternion

@:op(-A)staticinlinenegate(a:Quaternion):Quaternion


>>> ({ 
... var a = new Quaternion({ x: 1., y: 2., z: 3., w: 1. });
... var b = -a;
... b == new Quaternion({ x: -1., y: -2., z: -3., w: -1. }); }) == true

staticinlinenormalize(this:Mat1x4):Quaternion

@:op(A != B)staticinlinenotEqual(a:Quaternion, b:Quaternion):Bool


>>> ({ 
... var a = new Quaternion({ x: 1., y: 2., z: 3., w: 1. });
... var b = new Quaternion({ x: 1., y: 2., z: 4., w: 1. });
... a != b; }) == true

staticinlinescalarReal(s:Float):Quaternion

@:op(A * B)@:commutativestaticinlinescaleMultiply(a:Quaternion, v:Float):Quaternion

staticinlinescaled(this:Mat1x4, s:Float):Quaternion

staticslerp(this:Mat1x4, v1:Quaternion, t:Float):Quaternion

@:op(A - B)staticinlinesubtract(a:Quaternion, b:Quaternion):Quaternion


>>> ({ 
... var a = Quaternion.unit;
... a - a == Quaternion.zero; 
... }) == true

staticinlinetheta(this:Mat1x4, q:Quaternion):Float

angle in radians between to quaternions

@:tostaticinlinetoArray(this:Mat1x4):Array<Float>


>>> ({ 
... var a = Quaternion.unit;
... var b: Array = a;
... Equal.equals( b, [ 1., 1., 1., 1. ] ); }) == true

@:tostaticinlinetoMatrix3x3(this:Mat1x4):Matrix3x3

@:tostaticinlinetoMatrix4x1(this:Mat1x4):Matrix1x4

@:tostaticinlinetoMatrix4x3(this:Mat1x4):Matrix4x3

@:tostaticinlinetoVector(this:Mat1x4):Vector<Float>


>>> ({ 
... var a = Quaternion.unit;
... var b: haxe.ds.Vector = a;
... var c = haxe.ds.Vector.fromArrayCopy([ 1., 1., 1., 1. ]);
... Equal.equals( b, c ); }) == true

staticinlinexPI():Quaternion

staticinlinexPIhalf():Quaternion

staticinlinexPIhalfMinus():Quaternion

staticinlinexRotate(angle:Float):Quaternion

staticinlineyPI():Quaternion

staticinlineyPIhalf():Quaternion

staticinlineyPIhalfMinus():Quaternion

staticinlineyRotate(angle:Float):Quaternion

staticinlinezPI():Quaternion

staticinlinezPIhalf():Quaternion

staticinlinezPIhalfMinus():Quaternion

staticinlinezRotate(angle:Float):Quaternion