wmatrix4math.as

一个2D基于verlet的Flash物理引擎。它用AS3编写而成。Fisix的目标是应用到游戏等计算量很大的实时应用中。尽管flash比c/c++要慢,很棒的物理引擎

		public static function rotationY ( angle:Number ):WMatrix4
		{
			var m:WMatrix4 = WMatrix4.createIdentity();
			var c:Number = _aCos[int(angle)] ;
			var s:Number = _aSin[int(angle)] ;
			m.n11 =  c;
			m.n13 = -s;
			m.n31 =  s;
			m.n33 =  c;
			return m;
		}
		
		/**
		 * 
		 * @param angle Number angle of rotation in degrees
		 * @return the computed matrix
		 */
		public static function rotationZ ( angle:Number ):WMatrix4
		{
			var m:WMatrix4 = WMatrix4.createIdentity();
			var c:Number = _aCos[int(angle)] ;
			var s:Number = _aSin[int(angle)] ;
			m.n11 =  c;
			m.n12 =  s;
			m.n21 = -s;
			m.n22 =  c;
			return m;
		}
		
		/**
		 * Compute a Rotation around a Vector which represents the axis of rotation{@code Matrix4}.
		 *
		 * @param {@code v} The axis of rotation
		 * @param The angle of rotation in degree
		 * @return The result of computation : a {@code Matrix4}.
		 */
		public static function axisRotationVector ( v:WVector, angle:Number ) : WMatrix4
		{
			return WMatrix4Math.axisRotation( v.x, v.y, v.z, angle );
		}
		
		/**
		 * Compute a Rotation around an axis{@code Matrix4}.
		 *
		 * @param {@code nRotX} rotation X.
		 * @param {@code nRotY} rotation Y.
		 * @param {@code nRotZ} rotation Z.
		 * @param The angle of rotation in degree
		 * @return The result of computation : a {@code Matrix4}.
		 */
		public static function axisRotation ( u:Number, v:Number, w:Number, angle:Number ) : WMatrix4
		{
			var m:WMatrix4 	= WMatrix4.createIdentity();
			angle = WNumberUtil.toRadian( angle );
			// -- modification pour verifier qu'il n'y ai pas un probleme de precision avec la camera
			var nCos:Number	= Math.cos( angle );
			var nSin:Number	= Math.sin( angle );
			var scos:Number	= 1 - nCos ;

			var suv	:Number = u * v * scos ;
			var svw	:Number = v * w * scos ;
			var suw	:Number = u * w * scos ;
			var sw	:Number = nSin * w ;
			var sv	:Number = nSin * v ;
			var su	:Number = nSin * u ;
			
			m.n11  =   nCos + u * u * scos	;
			m.n12  = - sw 	+ suv 			;
			m.n13  =   sv 	+ suw			;

			m.n21  =   sw 	+ suv 			;
			m.n22  =   nCos + v * v * scos 	;
			m.n23  = - su 	+ svw			;

			m.n31  = - sv	+ suw 			;
			m.n32  =   su	+ svw 			;
			m.n33  =   nCos	+ w * w * scos	;

			return m;
		}
		
		/**
		 * Compute a translation {@code Matrix4}.
		 * 
		 * <pre>
		 * |1  0  0  0|
		 * |0  1  0  0|
		 * |0  0  1  0|
		 * |Tx Ty Tz 1|
		 * </pre>
		 * 
		 * @param {@code nTx} translation X.
		 * @param {@code nTy} translation Y.
		 * @param {@code nTz} translation Z.
		 * @return The result of computation : a {@code Matrix4}.
		 */
		public static function translation(nTx:Number, nTy:Number, nTz:Number) : WMatrix4 
		{
			var m : WMatrix4 = WMatrix4.createIdentity();
			m.n14 = nTx;
			m.n24 = nTy;
			m.n34 = nTz;
			return m;
		}

		/**
		 * Compute a translation from a vector {@code Matrix4}.
		 * 
		 * <pre>
		 * |1  0  0  0|
		 * |0  1  0  0|
		 * |0  0  1  0|
		 * |Tx Ty Tz 1|
		 * </pre>
		 * 
		 * @param {@code v} translation Vector.
		 * @return The result of computation : a {@code Matrix4}.
		 */
		public static function translationVector( v:WVector ) : WMatrix4 
		{
			var m : WMatrix4 = WMatrix4.createIdentity();
			m.n14 = v.x;
			m.n24 = v.y;
			m.n34 = v.z;
			return m;
		}
		
		/**
		 * Compute a scale {@code Matrix4}.
		 * 
		 * <pre>
		 * |Sx 0  0  0|
		 * |0  Sy 0  0|
		 * |0  0  Sz 0|
		 * |0  0  0  1|
		 * </pre>
		 *
		 * @param {@code nRotX} translation X.
		 * @param {@code nRotY} translation Y.
		 * @param {@code nRotZ} translation Z.
		 * @return The result of computation : a {@code Matrix}.
		 */
		public static function scale(nXScale:Number, nYScale:Number, nZScale:Number) : WMatrix4 
		{
			var matScale : WMatrix4 = WMatrix4.createIdentity();
			matScale.n11 = nXScale;
			matScale.n22 = nYScale;
			matScale.n33 = nZScale;
			return matScale;
		}
		
		/**
		 * Compute a scale {@code Matrix4}.
		 * 
		 * <pre>
		 * |Sx 0  0  0|
		 * |0  Sy 0  0|
		 * |0  0  Sz 0|
		 * |0  0  0  1|
		 * </pre>
		 *
		 * @param {@code Vector} The vector containing the scale values
		 * @return The result of computation : a {@code Matrix}.
		 */
		public static function scaleVector( v:WVector) : WMatrix4 
		{
			var matScale : WMatrix4 = WMatrix4.createIdentity();
			matScale.n11 = v.x;
			matScale.n22 = v.y;
			matScale.n33 = v.z;
			return matScale;
		}
			
		/**
		* Compute the determinant of the 4x4 square matrix
		* @param m a Matrix4
		* @return Number the determinant
		*/
		public static function det( m:WMatrix4 ):Number
		{
			return	(m.n11 * m.n22 - m.n21 * m.n12) * (m.n33 * m.n44 - m.n43 * m.n34)- (m.n11 * m.n32 - m.n31 * m.n12) * (m.n23 * m.n44 - m.n43 * m.n24)
					 + 	(m.n11 * m.n42 - m.n41 * m.n12) * (m.n23 * m.n34 - m.n33 * m.n24)+ (m.n21 * m.n32 - m.n31 * m.n22) * (m.n13 * m.n44 - m.n43 * m.n14)
					 - 	(m.n21 * m.n42 - m.n41 * m.n22) * (m.n13 * m.n34 - m.n33 * m.n14)+ (m.n31 * m.n42 - m.n41 * m.n32) * (m.n13 * m.n24 - m.n23 * m.n14);

		}
		
		public static function det3x3( m:WMatrix4 ):Number
		{	
			return m.n11 * ( m.n22 * m.n33 - m.n23 * m.n32 ) + m.n21 * ( m.n32 * m.n13 - m.n12 * m.n33 ) + m.n31 * ( m.n12 * m.n23 - m.n22 * m.n13 );
		}


		/**
		 * Computes the trace of the matrix.
		 * @param m Matrix4 The matrix we want to compute the trace
		 * @return The trace value which is the sum of the element on the diagonal
		 */
		public static function getTrace( m:WMatrix4 ):Number
		{
			return m.n11 + m.n22 + m.n33 + m.n44;
		}
		
		/**
		* Return the inverse of the matrix passed in parameter.
		* @param m The matrix4 to inverse
		* @return Matrix4 The inverse Matrix4
		*/
		public static function getInverse( m:WMatrix4 ):WMatrix4
		{
			//take the determinant
			var d:Number = WMatrix4Math.det( m );
			if( Math.abs(d) < 0.001 )
			{
				//We cannot invert a matrix with a null determinant
				return null;
			}
			//We use Cramer formula, so we need to devide by the determinant. We prefer multiply by the inverse
			d = 1/d;
			var m11:Number = m.n11;var m21:Number = m.n21;var m31:Number = m.n31;var m41:Number = m.n41;
			var m12:Number = m.n12;var m22:Number = m.n22;var m32:Number = m.n32;var m42:Number = m.n42;
			var m13:Number = m.n13;var m23:Number = m.n23;var m33:Number = m.n33;var m43:Number = m.n43;
			var m14:Number = m.n14;var m24:Number = m.n24;var m34:Number = m.n34;var m44:Number = m.n44;
			return new WMatrix4 (
				d * ( m22*(m33*m44 - m43*m34) - m32*(m23*m44 - m43*m24) + m42*(m23*m34 - m33*m24) ),
				-d* ( m12*(m33*m44 - m43*m34) - m32*(m13*m44 - m43*m14) + m42*(m13*m34 - m33*m14) ),
				d * ( m12*(m23*m44 - m43*m24) - m22*(m13*m44 - m43*m14) + m42*(m13*m24 - m23*m14) ),
				-d* ( m12*(m23*m34 - m33*m24) - m22*(m13*m34 - m33*m14) + m32*(m13*m24 - m23*m14) ),
				-d* ( m21*(m33*m44 - m43*m34) - m31*(m23*m44 - m43*m24) + m41*(m23*m34 - m33*m24) ),
				d * ( m11*(m33*m44 - m43*m34) - m31*(m13*m44 - m43*m14) + m41*(m13*m34 - m33*m14) ),
				-d* ( m11*(m23*m44 - m43*m24) - m21*(m13*m44 - m43*m14) + m41*(m13*m24 - m23*m14) ),
				d * ( m11*(m23*m34 - m33*m24) - m21*(m13*m34 - m33*m14) + m31*(m13*m24 - m23*m14) ),
				d * ( m21*(m32*m44 - m42*m34) - m31*(m22*m44 - m42*m24) + m41*(m22*m34 - m32*m24) ),
				-d* ( m11*(m32*m44 - m42*m34) - m31*(m12*m44 - m42*m14) + m41*(m12*m34 - m32*m14) ),
				d * ( m11*(m22*m44 - m42*m24) - m21*(m12*m44 - m42*m14) + m41*(m12*m24 - m22*m14) ),
				-d* ( m11*(m22*m34 - m32*m24) - m21*(m12*m34 - m32*m14) + m31*(m12*m24 - m22*m14) ),
				-d* ( m21*(m32*m43 - m42*m33) - m31*(m22*m43 - m42*m23) + m41*(m22*m33 - m32*m23) ),
				d * ( m11*(m32*m43 - m42*m33) - m31*(m12*m43 - m42*m13) + m41*(m12*m33 - m32*m13) ),
				-d* ( m11*(m22*m43 - m42*m23) - m21*(m12*m43 - m42*m13) + m41*(m12*m23 - m22*m13) ),
				d * ( m11*(m22*m33 - m32*m23) - m21*(m12*m33 - m32*m13) + m31*(m12*m23 - m22*m13) )
				);
		}
		
		
		/**
		 * Realize a rotation around a specific axis (the axis must be normalized!) and from an pangle degrees and around a specific position.
		 * @param pAxis A 3D Vector representing the axis of rtation. Must be normalized
		 * @param ref Vector The center of rotation as a 3D point.
		 * @param pAngle Number The angle of rotation in degrees.
		 */
		public static function axisRotationWithReference( axis:WVector, ref:WVector, pAngle:Number ):WMatrix4
		{
			var angle:Number = ( pAngle + 360 ) % 360;
			var m:WMatrix4 = WMatrix4Math.translation ( ref.x, -ref.y, ref.z );
			m = WMatrix4Math.multiply ( m, WMatrix4Math.axisRotation( axis.x, axis.y, axis.z, angle ));
			m = WMatrix4Math.multiply ( m, WMatrix4Math.translation ( -ref.x, ref.y, -ref.z ));
			return m;
		}

		
		/////////////
		// PRIVATE
		/////////////	
		private static var _aSin : Array = new Array(360);
		private static var _aCos : Array = new Array(360);
		private static var _bIsPrecalculed : Boolean = false;
		private static var _bMatrixExtends : Boolean = WMatrix4Math.preCalc();

		/**
		 * Constructor
		 */
		public function WMatrix4Math (singletonBlocker:WSingletonBlocker)
		{
			//empty
		}
		
		private static function preCalc() : Boolean 
		{
			if(_bIsPrecalculed) 
				return true;
			
			_bIsPrecalculed = true;
			
			for( var nAlpha:Number = 0; nAlpha < 360; nAlpha++ ) 
			{
				_aSin[nAlpha] = WFastMath.sin(nAlpha*Math.PI/180);
				_aCos[nAlpha] = WFastMath.cos(nAlpha*Math.PI/180);
			}
			return true;
		}
	}
}

class WSingletonBlocker {}