/* -----------------------------------------------------------------------------
	３Ｄゲームで使用するアフィン変換用４行３列の行列計算用関数集
	ファイル名	:	mtx44.as
	as.Ver		:	AS 1.0 Flash 5 以降
	製作		:	Hakuhin	(C)	2006/11/17
 ----------------------------------------------------------------------------- */

/* -----------------------------------------------------------------------------

	--------------------------------------
	マトリックスの型
	--------------------------------------
	matrix = {
		_00 : 1,	_01 : 0,	_02 : 0,
		_10 : 0,	_11 : 1,	_12 : 0,
		_20 : 0,	_21 : 0,	_22 : 1,
		_30 : 0,	_31 : 0,	_32 : 0
	}
	--------------------------------------
	
	４行３列のオブジェクトで管理しています。計算上は４行４列ですが
	４列目は使わないのでその分の処理を省いています。


	// 行列用関数 -------------------------------------------------------
	function Mtx44Create();					// マトリックス作成
	function Mtx44Clone(m);					// マトリックスコピー
	function Mtx44Identity(m);				// マトリックス単位行列化
	function Mtx44GetRight(m);				// x ベクトル成分取得
	function Mtx44GetUp(m);					// y ベクトル成分取得
	function Mtx44GetAt(m);					// z ベクトル成分取得
	function Mtx44GetPos(m);				// 座標成分取得
	function Mtx44OrthoNormalize(m);		// 正規直交行列化

	// 平行移動行列 -----------------------------------------------------
	function Mtx44Translate(vec);			// 平行行列作成
	function Mtx44TranslatePref(vec,m);		// 平行行列 * 指定行列
	function Mtx44TranslatePost(vec,m);		// 指定行列 * 平行行列

	// x 軸回転行列 -----------------------------------------------------
	function Mtx44RotateX(rot);				// 回転行列作成
	function Mtx44RotateXPref(rot,m);		// 回転行列 * 指定行列
	function Mtx44RotateXPost(rot,m);		// 指定行列 * 回転行列

	// y 軸回転行列 -----------------------------------------------------
	function Mtx44RotateY(rot);				// 回転行列作成
	function Mtx44RotateYPref(rot,m);		// 回転行列 * 指定行列
	function Mtx44RotateYPost(rot,m);		// 指定行列 * 回転行列

	// z 軸回転行列 -----------------------------------------------------
	function Mtx44RotateZ(rot);				// 回転行列作成
	function Mtx44RotateZPref(rot,m);		// 回転行列 * 指定行列
	function Mtx44RotateZPost(rot,m);		// 指定行列 * 回転行列

	// 任意軸回転行列 ---------------------------------------------------
	function Mtx44Rotate(vec,rot);			// 回転行列作成
	function Mtx44RotatePref(vec,rot,m);	// 回転行列 * 指定行列
	function Mtx44RotatePost(vec,rot,m);	// 指定行列 * 回転行列

	// 拡大縮小行列 -----------------------------------------------------
	function Mtx44Scale(vec);				// 拡縮行列作成
	function Mtx44ScalePref(vec,m);			// 拡縮行列 * 指定行列
	function Mtx44ScalePost(vec,m);			// 指定行列 * 拡縮行列

	// 射影変換 ---------------------------------------------------------
	function Vec3dTransformPoint (vec,m); 	// 点の射影
	function Vec3dTransformVector(vec,m);	// ベクトルの射影
	function Mtx44Transform  (m,m);			// 行列の射影(行列 * 行列)

	// 逆行列 ---------------------------------------------------------
	function Mtx44InvertOrthoNormal (m); 	// 逆マトリックスを計算(正規直交行列用)
	function Mtx44Invert (m);				// 逆マトリックスを計算

	注.Mtx44Transform() は計算量が多いので
	*Pref *Post 関数で計算できるときはそっちを優先して使用すること
 ----------------------------------------------------------------------------- */


// ------------------------------------------
// ４行４列関数
// ------------------------------------------

/* ------------------------------------------------------------------- 
	マトリックス作成
 ------------------------------------------------------------------- */
function Mtx44Create(){
	return {
		_00 : 1 ,_01 : 0 ,_02 : 0,
		_10 : 0 ,_11 : 1 ,_12 : 0,
		_20 : 0 ,_21 : 0 ,_22 : 1,
		_30 : 0 ,_31 : 0 ,_32 : 0
	};
}


/* ------------------------------------------------------------------- 
	マトリックスコピー
 ------------------------------------------------------------------- */
function Mtx44Clone(m){
	return {
		_00 : m._00 ,_01 : m._01 ,_02 : m._02,
		_10 : m._10 ,_11 : m._11 ,_12 : m._12,
		_20 : m._20 ,_21 : m._21 ,_22 : m._22,
		_30 : m._30 ,_31 : m._31 ,_32 : m._32
	};
}


/* ------------------------------------------------------------------- 
	マトリックス単位行列化
 ------------------------------------------------------------------- */
function Mtx44Identity(m){
	m._00 = 1.0; m._01 = 0.0; m._02 = 0.0;
	m._10 = 0.0; m._11 = 1.0; m._12 = 0.0;
	m._20 = 0.0; m._21 = 0.0; m._22 = 1.0;
	m._30 = 0.0; m._31 = 0.0; m._32 = 0.0;
	return m;
}


/* ------------------------------------------------------------------- 
	x ベクトル成分取得
 ------------------------------------------------------------------- */
function Mtx44GetRight(m){
	return { x : m._00, y : m._01, z : m._02 };
}


/* ------------------------------------------------------------------- 
	y ベクトル成分取得
 ------------------------------------------------------------------- */
function Mtx44GetUp(m){
	return { x : m._10, y : m._11, z : m._12 };
}


/* ------------------------------------------------------------------- 
	z ベクトル成分取得
 ------------------------------------------------------------------- */
function Mtx44GetAt(m){
	return { x : m._20, y : m._21, z : m._22 };
}


/* ------------------------------------------------------------------- 
	座標成分取得
 ------------------------------------------------------------------- */
function Mtx44GetPos(m){
	return { x : m._30, y : m._31, z : m._32 };
}


/* ------------------------------------------------------------------- 
	平行行列作成
 ------------------------------------------------------------------- */
function Mtx44Translate(vec){
	return {
		_00 : 1.0,		_01 : 0.0,		_02 : 0.0,
		_10 : 0.0,		_11 : 1.0,		_12 : 0.0,
		_20 : 0.0,		_21 : 0.0,		_22 : 1.0,
		_30 : vec.x,	_31 : vec.y,	_32 : vec.z
	};
}


/* ------------------------------------------------------------------- 
	平行移動行列計算(平行行列 * 指定行列)
 ------------------------------------------------------------------- */
function Mtx44TranslatePref(vec,m){
	return {
		_00 : m._00,
		_01 : m._01,
		_02 : m._02,
		_10 : m._10,
		_11 : m._11,
		_12 : m._12,
		_20 : m._20,
		_21 : m._21,
		_22 : m._22,
		_30 : vec.x * m._00 + vec.y * m._10 + vec.z * m._20 + m._30,
		_31 : vec.x * m._01 + vec.y * m._11 + vec.z * m._21 + m._31,
		_32 : vec.x * m._02 + vec.y * m._12 + vec.z * m._22 + m._32
	};
}


/* ------------------------------------------------------------------- 
	平行移動行列計算(指定行列 * 平行行列)
 ------------------------------------------------------------------- */
function Mtx44TranslatePost(vec,m){
	return {
		_00 : m._00,
		_01 : m._01,
		_02 : m._02,
		_10 : m._10,
		_11 : m._11,
		_12 : m._12,
		_20 : m._20,
		_21 : m._21,
		_22 : m._22,
		_30 : m._30 + vec.x,
		_31 : m._31 + vec.y,
		_32 : m._32 + vec.z
	};
}


/* ------------------------------------------------------------------- 
	x 軸回転行列作成
 ------------------------------------------------------------------- */
function Mtx44RotateX(rot){
	
	var rad = rot * Math.PI / 180;
	var cos = Math.cos(rad);
	var sin = Math.sin(rad);

	return {
		_00 : 1.0,	_01 : 0.0,	_02 : 0.0,
		_10 : 0.0,	_11 : cos, 	_12 : sin,
		_20 : 0.0,	_21 : -sin,	_22 : cos,
		_30 : 0.0,	_31 : 0.0,	_32 : 0.0
	};
}


/* ------------------------------------------------------------------- 
	x 軸回転行列計算(回転行列 * 指定行列)
 ------------------------------------------------------------------- */
function Mtx44RotateXPref(rot,m){
	
	var rad = rot * Math.PI / 180;
	var cos = Math.cos(rad);
	var sin = Math.sin(rad);

	return {
		_00 : m._00,
		_01 : m._01,
		_02 : m._02,
		_10 : cos * m._10 + sin * m._20,
		_11 : cos * m._11 + sin * m._21,
		_12 : cos * m._12 + sin * m._22,
		_20 : -sin * m._10 + cos * m._20,
		_21 : -sin * m._11 + cos * m._21,
		_22 : -sin * m._12 + cos * m._22,
		_30 : m._30,
		_31 : m._31,
		_32 : m._32
	};
}


/* ------------------------------------------------------------------- 
	x 軸回転行列計算(指定行列 * 回転行列)
 ------------------------------------------------------------------- */
function Mtx44RotateXPost(rot,m){
	
	var rad = rot * Math.PI / 180;
	var cos = Math.cos(rad);
	var sin = Math.sin(rad);

	return {
		_00 : m._00,
		_01 : m._01 * cos - m._02 * sin,
		_02 : m._01 * sin + m._02 * cos,
		_10 : m._10,
		_11 : m._11 * cos - m._12 * sin,
		_12 : m._11 * sin + m._12 * cos,
		_20 : m._20,
		_21 : m._21 * cos - m._22 * sin,
		_22 : m._21 * sin + m._22 * cos,
		_30 : m._30,
		_31 : m._31 * cos - m._32 * sin,
		_32 : m._31 * sin + m._32 * cos
	};
}


/* ------------------------------------------------------------------- 
	y 軸回転行列作成
 ------------------------------------------------------------------- */
function Mtx44RotateY(rot){
	
	var rad = rot * Math.PI / 180;
	var cos = Math.cos(rad);
	var sin = Math.sin(rad);

	return {
		_00 : cos,	_01 : 0.0,	_02 : -sin,
		_10 : 0.0,	_11 : 1.0,	_12 : 0.0,
		_20 : sin,	_21 : 0.0,	_22 : cos,
		_30 : 0.0,	_31 : 0.0,	_32 : 0.0
	};
}


/* ------------------------------------------------------------------- 
	y 軸回転行列計算(回転行列 * 指定行列)
 ------------------------------------------------------------------- */
function Mtx44RotateYPref(rot,m){
	
	var rad = rot * Math.PI / 180;
	var cos = Math.cos(rad);
	var sin = Math.sin(rad);

	return {
		_00 : cos * m._00 - sin * m._20,
		_01 : cos * m._01 - sin * m._21,
		_02 : cos * m._02 - sin * m._22,
		_10 : m._10,
		_11 : m._11,
		_12 : m._12,
		_20 : sin * m._00 + cos * m._20,
		_21 : sin * m._01 + cos * m._21,
		_22 : sin * m._02 + cos * m._22,
		_30 : m._30,
		_31 : m._31,
		_32 : m._32
	};
}


/* ------------------------------------------------------------------- 
	y 軸回転行列計算(指定行列 * 回転行列)
 ------------------------------------------------------------------- */
function Mtx44RotateYPost(rot,m){
	
	var rad = rot * Math.PI / 180;
	var cos = Math.cos(rad);
	var sin = Math.sin(rad);

	return {
		_00 : m._00 * cos + m._02 * sin,
		_01 : m._01,
		_02 : m._00 *-sin + m._02 * cos,
		_10 : m._10 * cos + m._12 * sin,
		_11 : m._11,
		_12 : m._10 *-sin + m._12 * cos,
		_20 : m._20 * cos + m._22 * sin,
		_21 : m._21,
		_22 : m._20 *-sin + m._22 * cos,
		_30 : m._30 * cos + m._32 * sin,
		_31 : m._31,
		_32 : m._30 *-sin + m._32 * cos
	};
}


/* ------------------------------------------------------------------- 
	z 軸回転行列作成
 ------------------------------------------------------------------- */
function Mtx44RotateZ(rot){
	
	var rad = rot * Math.PI / 180;
	var cos = Math.cos(rad);
	var sin = Math.sin(rad);

	return {
		_00 :  cos,	_01 : sin,	_02 : 0.0,
		_10 : -sin,	_11 : cos,	_12 : 0.0,
		_20 :  0.0,	_21 : 0.0,	_22 : 1.0,
		_30 :  0.0,	_31 : 0.0,	_32 : 0.0		
	};
}


/* ------------------------------------------------------------------- 
	z 軸回転行列計算(回転行列 * 指定行列)
 ------------------------------------------------------------------- */
function Mtx44RotateZPref(rot,m){

	var rad = rot * Math.PI / 180;
	var cos = Math.cos(rad);
	var sin = Math.sin(rad);

	return {
		_00 : cos * m._00 + sin * m._10,
		_01 : cos * m._01 + sin * m._11,
		_02 : cos * m._02 + sin * m._12,
		_10 : -sin * m._00 + cos * m._10,
		_11 : -sin * m._01 + cos * m._11,
		_12 : -sin * m._02 + cos * m._12,
		_20 : m._20,
		_21 : m._21,
		_22 : m._22,
		_30 : m._30,
		_31 : m._31,
		_32 : m._32
	};
}


/* ------------------------------------------------------------------- 
	z 軸回転行列計算(指定行列 * 回転行列)
 ------------------------------------------------------------------- */
function Mtx44RotateZPost(rot,m){

	var rad = rot * Math.PI / 180;
	var cos = Math.cos(rad);
	var sin = Math.sin(rad);

	return {
		_00 : m._00 * cos - m._01 * sin,
		_01 : m._00 * sin + m._01 * cos,
		_02 : m._02,
		_10 : m._10 * cos - m._11 * sin,
		_11 : m._10 * sin + m._11 * cos,
		_12 : m._12,
		_20 : m._20 * cos - m._21 * sin,
		_21 : m._20 * sin + m._21 * cos,
		_22 : m._22,
		_30 : m._30 * cos - m._31 * sin,
		_31 : m._30 * sin + m._31 * cos,
		_32 : m._32
	};
}


/* ------------------------------------------------------------------- 
	回転軸指定行列作成
 ------------------------------------------------------------------- */
function Mtx44Rotate(vec,rot){
	var rad = rot * Math.PI / 180;

	var c = Math.cos(rad);
	var s = Math.sin(rad);
	var t = 1.0 - Math.cos(rad);

	var x = 0;
	var y = 0;
	var z = 0;
	var length = Math.sqrt((vec.x * vec.x) + (vec.y * vec.y) + (vec.z * vec.z));
	if(length != 0.0){
		x = vec.x / length;
		y = vec.y / length;
		z = vec.z / length;
	}

	return {
		_00 : t * x * x + c,
		_01 : t * y * x + s * z,
		_02 : t * z * x - s * y,
		_10 : t * x * y - s * z,
		_11 : t * y * y + c,
		_12 : t * z * y + s * x,
		_20 : t * x * z + s * y,
		_21 : t * y * z - s * x,
		_22 : t * z * z + c,
		_30 : 0.0,
		_31 : 0.0,
		_32 : 0.0
	};
}


/* ------------------------------------------------------------------- 
	回転軸指定回転行列計算(回転行列 * 指定行列)
 ------------------------------------------------------------------- */
function Mtx44RotatePref(vec,rot,m){
	var rad = rot * Math.PI / 180;

	var c = Math.cos(rad);
	var s = Math.sin(rad);
	var t = 1.0 - Math.cos(rad);

	var x = 0;
	var y = 0;
	var z = 0;
	var length = Math.sqrt((vec.x * vec.x) + (vec.y * vec.y) + (vec.z * vec.z));
	if(length != 0.0){
		x = vec.x / length;
		y = vec.y / length;
		z = vec.z / length;
	}

	var _00 = t * x * x + c;
	var _01 = t * y * x + s * z;
	var _02 = t * z * x - s * y;
	var _10 = t * x * y - s * z;
	var _11 = t * y * y + c;
	var _12 = t * z * y + s * x;
	var _20 = t * x * z + s * y;
	var _21 = t * y * z - s * x;
	var _22 = t * z * z + c;

	return {
		_00 : _00 * m._00 + _01 * m._10 + _02 * m._20,
		_01 : _00 * m._01 + _01 * m._11 + _02 * m._21,
		_02 : _00 * m._02 + _01 * m._12 + _02 * m._22,
		_10 : _10 * m._00 + _11 * m._10 + _12 * m._20,
		_11 : _10 * m._01 + _11 * m._11 + _12 * m._21,
		_12 : _10 * m._02 + _11 * m._12 + _12 * m._22,
		_20 : _20 * m._00 + _21 * m._10 + _22 * m._20,
		_21 : _20 * m._01 + _21 * m._11 + _22 * m._21,
		_22 : _20 * m._02 + _21 * m._12 + _22 * m._22,
		_30 : m._30,
		_31 : m._31,
		_32 : m._32
	};
}


/* ------------------------------------------------------------------- 
	回転軸指定回転行列計算(指定行列 * 回転行列)
 ------------------------------------------------------------------- */
function Mtx44RotatePost(vec,rot,m){
	var rad = rot * Math.PI / 180;

	var c = Math.cos(rad);
	var s = Math.sin(rad);
	var t = 1.0 - Math.cos(rad);

	var x = 0;
	var y = 0;
	var z = 0;
	var length = Math.sqrt((vec.x * vec.x) + (vec.y * vec.y) + (vec.z * vec.z));
	if(length != 0.0){
		x = vec.x / length;
		y = vec.y / length;
		z = vec.z / length;
	}

	var _00 = t * x * x + c;
	var _01 = t * y * x + s * z;
	var _02 = t * z * x - s * y;
	var _10 = t * x * y - s * z;
	var _11 = t * y * y + c;
	var _12 = t * z * y + s * x;
	var _20 = t * x * z + s * y;
	var _21 = t * y * z - s * x;
	var _22 = t * z * z + c;

	return {
		_00 : m._00 * _00 + m._01 * _10 + m._02 * _20,
		_01 : m._00 * _01 + m._01 * _11 + m._02 * _21,
		_02 : m._00 * _02 + m._01 * _12 + m._02 * _22,
		_10 : m._10 * _00 + m._11 * _10 + m._12 * _20,
		_11 : m._10 * _01 + m._11 * _11 + m._12 * _21,
		_12 : m._10 * _02 + m._11 * _12 + m._12 * _22,
		_20 : m._20 * _00 + m._21 * _10 + m._22 * _20,
		_21 : m._20 * _01 + m._21 * _11 + m._22 * _21,
		_22 : m._20 * _02 + m._21 * _12 + m._22 * _22,
		_30 : m._30 * _00 + m._31 * _10 + m._32 * _20,
		_31 : m._30 * _01 + m._31 * _11 + m._32 * _21,
		_32 : m._30 * _02 + m._31 * _12 + m._32 * _22
	};
}


/* ------------------------------------------------------------------- 
	拡大縮小行列作成
 ------------------------------------------------------------------- */
function Mtx44Scale(vec){	
	return {
		_00 : vec.x,	_01 : 0.0,		_02 : 0.0,
		_10 : 0.0,		_11 : vec.y,	_12 : 0.0,
		_20 : 0.0,		_21 : 0.0,		_22 : vec.z,
		_30 : 0.0,		_31 : 0.0,		_32 : 0.0
	};
}


/* ------------------------------------------------------------------- 
	拡大縮小行列計算(拡縮行列 * 指定行列)
 ------------------------------------------------------------------- */
function Mtx44ScalePref(vec ,m){
	return {
		_00 : vec.x * m._00,
		_01 : vec.x * m._01,
		_02 : vec.x * m._02,
		_10 : vec.y * m._10,
		_11 : vec.y * m._11,
		_12 : vec.y * m._12,
		_20 : vec.z * m._20,
		_21 : vec.z * m._21,
		_22 : vec.z * m._22,
		_30 : m._30,
		_31 : m._31,
		_32 : m._32
	};
}


/* ------------------------------------------------------------------- 
	拡大縮小行列計算(指定行列 * 拡縮行列)
 ------------------------------------------------------------------- */
function Mtx44ScalePost(m,vec){
	return {
		_00 : m._00 * vec.x,
		_01 : m._01 * vec.y,
		_02 : m._02 * vec.z,
		_10 : m._10 * vec.x,
		_11 : m._11 * vec.y,
		_12 : m._12 * vec.z,
		_20 : m._20 * vec.x,
		_21 : m._21 * vec.y,
		_22 : m._22 * vec.z,
		_30 : m._30 * vec.x,
		_31 : m._31 * vec.y,
		_32 : m._32 * vec.z
	};

}


/* ------------------------------------------------------------------- 
	点の射影変換
 ------------------------------------------------------------------- */
function Vec3dTransformPoint(vec,m){
	return {
		x : vec.x * m._00 + vec.y * m._10 + vec.z * m._20 + m._30,
		y : vec.x * m._01 + vec.y * m._11 + vec.z * m._21 + m._31,
		z : vec.x * m._02 + vec.y * m._12 + vec.z * m._22 + m._32
	};
}


/* ------------------------------------------------------------------- 
	ベクトルの射影変換
 ------------------------------------------------------------------- */
function Vec3dTransformVector (vec,m){
	return {
		x : vec.x * m._00 + vec.y * m._10 + vec.z * m._20,
		y : vec.x * m._01 + vec.y * m._11 + vec.z * m._21,
		z : vec.x * m._02 + vec.y * m._12 + vec.z * m._22
	};
};


/* ------------------------------------------------------------------- 
	マトリックス同士の計算
 ------------------------------------------------------------------- */
function Mtx44Transform  (m1,m2){
	return {
		_00 : m1._00 * m2._00 + m1._01 * m2._10 + m1._02 * m2._20,
		_01 : m1._00 * m2._01 + m1._01 * m2._11 + m1._02 * m2._21,
		_02 : m1._00 * m2._02 + m1._01 * m2._12 + m1._02 * m2._22,
		_10 : m1._10 * m2._00 + m1._11 * m2._10 + m1._12 * m2._20,
		_11 : m1._10 * m2._01 + m1._11 * m2._11 + m1._12 * m2._21,
		_12 : m1._10 * m2._02 + m1._11 * m2._12 + m1._12 * m2._22,
		_20 : m1._20 * m2._00 + m1._21 * m2._10 + m1._22 * m2._20,
		_21 : m1._20 * m2._01 + m1._21 * m2._11 + m1._22 * m2._21,
		_22 : m1._20 * m2._02 + m1._21 * m2._12 + m1._22 * m2._22,
		_30 : m1._30 * m2._00 + m1._31 * m2._10 + m1._32 * m2._20 + m2._30,
		_31 : m1._30 * m2._01 + m1._31 * m2._11 + m1._32 * m2._21 + m2._31,
		_32 : m1._30 * m2._02 + m1._31 * m2._12 + m1._32 * m2._22 + m2._32
	};
};


/* ------------------------------------------------------------------- 
	正規直交行列用の逆マトリックスを作成
 ------------------------------------------------------------------- */
function Mtx44InvertOrthoNormal (m){
	return {
		_00 : m._00,
		_01 : m._10,
		_02 : m._20,
		_10 : m._01,
		_11 : m._11,
		_12 : m._21,
		_20 : m._02,
		_21 : m._12,
		_22 : m._22,
		_30 : -(m._00 * m._30 + m._10 * m._31 + m._20 * m._32),
		_31 : -(m._01 * m._30 + m._11 * m._31 + m._21 * m._32),
		_32 : -(m._02 * m._30 + m._12 * m._31 + m._22 * m._32)
	};
}


/* ------------------------------------------------------------------- 
	逆マトリックスを計算
 ------------------------------------------------------------------- */
function Mtx44Invert (m2){
	
	var m1 = {
		_00 : 1,	_01 : 0,	_02 : 0,
		_10 : 0,	_11 : 1,	_12 : 0,
		_20 : 0,	_21 : 0,	_22 : 1,
		_30 : 0,	_31 : 0,	_32 : 0
	};

	var _01 = m2._01;	var _02 = m2._02;
	var _11 = m2._11;	var _12 = m2._12;
	var _21 = m2._21;	var _22 = m2._22;
	var _31 = m2._31;	var _32 = m2._32;

	if(m2._00){
		m1._00 /= m2._00;
		_02 /= m2._00;
		_01 /= m2._00;
	}
	_11 -= m2._10 * _01;
	_12 -= m2._10 * _02;
	m1._10 -= m2._10 * m1._00;
	_21 -= m2._20 * _01;
	_22 -= m2._20 * _02;
	m1._20 -= m2._20 * m1._00;
	_31 -= m2._30 * _01;
	_32 -= m2._30 * _02;
	m1._30 -= m2._30 * m1._00;

	if(_11){
		m1._10 /= _11;
		_12 /= _11;
	}
	_22 -= _21 * _12;
	m1._20 -= _21 * m1._10;
	_32 -= _31 * _12;
	m1._30 -= _31 * m1._10;

	if(_22){
		m1._20 /= _22;
	}
	m1._30 -= _32 * m1._20;
	m1._10 -= _12 * m1._20;
	m1._00 -= _02 * m1._20;
	m1._00 -= _01 * m1._10;


	_01 = m2._01;	_02 = m2._02;
	_11 = m2._11;	_12 = m2._12;
	_21 = m2._21;	_22 = m2._22;
	_31 = m2._31;	_32 = m2._32;

	if(m2._00){
		m1._01 /= m2._00;
		_02 /= m2._00;
		_01 /= m2._00;
	}
	_11 -= m2._10 * _01;
	_12 -= m2._10 * _02;
	m1._11 -= m2._10 * m1._01;
	_21 -= m2._20 * _01;
	_22 -= m2._20 * _02;
	m1._21 -= m2._20 * m1._01;
	_31 -= m2._30 * _01;
	_32 -= m2._30 * _02;
	m1._31 -= m2._30 * m1._01;

	if(_11){
		m1._11 /= _11;
		_12 /= _11;
	}
	_22 -= _21 * _12;
	m1._21 -= _21 * m1._11;
	_32 -= _31 * _12;
	m1._31 -= _31 * m1._11;

	if(_22){
		m1._21 /= _22;
	}
	m1._31 -= _32 * m1._21;
	m1._11 -= _12 * m1._21;
	m1._01 -= _02 * m1._21;
	m1._01 -= _01 * m1._11;


	_01 = m2._01;	_02 = m2._02;
	_11 = m2._11;	_12 = m2._12;
	_21 = m2._21;	_22 = m2._22;
	_31 = m2._31;	_32 = m2._32;

	if(m2._00){
		m1._02 /= m2._00;
		_02 /= m2._00;
		_01 /= m2._00;
	}
	_11 -= m2._10 * _01;
	_12 -= m2._10 * _02;
	m1._12 -= m2._10 * m1._02;
	_21 -= m2._20 * _01;
	_22 -= m2._20 * _02;
	m1._22 -= m2._20 * m1._02;
	_31 -= m2._30 * _01;
	_32 -= m2._30 * _02;
	m1._32 -= m2._30 * m1._02;

	if(_11){
		m1._12 /= _11;
		_12 /= _11;
	}
	_22 -= _21 * _12;
	m1._22 -= _21 * m1._12;
	_32 -= _31 * _12;
	m1._32 -= _31 * m1._12;

	if(_22){
		m1._22 /= _22;
	}
	m1._32 -= _32 * m1._22;
	m1._12 -= _12 * m1._22;
	m1._02 -= _02 * m1._22;
	m1._02 -= _01 * m1._12;

	return m1;
}


/* ------------------------------------------------------------------- 
	正規直交行列化
 ------------------------------------------------------------------- */
function Mtx44OrthoNormalize(m2){
	var i;
	var length;
	var dot = [0,0,0];
	var num = [0,1,2];
	var m1 = new Object();

	length = Math.sqrt((m2._00 * m2._00) + (m2._01 * m2._01) + (m2._02 * m2._02));
	if(length){
		length = 1.0 / length; 
		m1._00 = m2._00 * length;
		m1._01 = m2._01 * length;
		m1._02 = m2._02 * length;
	}

	length = Math.sqrt((m2._10 * m2._10) + (m2._11 * m2._11) + (m2._12 * m2._12));
	if(length){
		length = 1.0 / length; 
		m1._10 = m2._10 * length;
		m1._11 = m2._11 * length;
		m1._12 = m2._12 * length;
	}

	length = Math.sqrt((m2._20 * m2._20) + (m2._21 * m2._21) + (m2._22 * m2._22));
	if(length){
		length = 1.0 / length; 
		m1._20 = m2._20 * length;
		m1._21 = m2._21 * length;
		m1._22 = m2._22 * length;
	}

	dot[0] = Math.abs((m1._00 * m1._10) + (m1._01 * m1._11) + (m1._02 * m1._12));
	dot[1] = Math.abs((m1._10 * m1._20) + (m1._11 * m1._21) + (m1._12 * m1._22));
	dot[2] = Math.abs((m1._20 * m1._00) + (m1._21 * m1._01) + (m1._22 * m1._02));

	for(i = 1;i >= 0;i--){
		if(dot[i+1] < dot[i]){
			var tmp_dot = dot[i+1];
			var tmp_num = num[i+1];
			dot[i+1] = dot[i];
			num[i+1] = num[i];
			dot[i] = tmp_dot;
			num[i] = tmp_num;
		}
	}
	
	if(num[0] == 0){
		m1._20 = (m1._01 * m2._12) - (m1._02 * m2._11);
		m1._21 = (m1._02 * m2._10) - (m1._00 * m2._12);
		m1._22 = (m1._00 * m2._11) - (m1._01 * m2._10);

		length = Math.sqrt((m1._20 * m1._20) + (m1._21 * m1._21) + (m1._22 * m1._22));
		if(length){
			length = 1.0 / length; 
			m1._20 = m1._20 * length;
			m1._21 = m1._21 * length;
			m1._22 = m1._22 * length;
		}

		m1._10 = (m1._21 * m1._02) - (m1._22 * m1._01);
		m1._11 = (m1._22 * m1._00) - (m1._20 * m1._02);
		m1._12 = (m1._20 * m1._01) - (m1._21 * m1._00);

	}else if(num[0] == 1){
		m1._00 = (m1._11 * m2._22) - (m1._12 * m2._21);
		m1._01 = (m1._12 * m2._20) - (m1._10 * m2._22);
		m1._02 = (m1._10 * m2._21) - (m1._11 * m2._20);

		length = Math.sqrt((m1._00 * m1._00) + (m1._01 * m1._01) + (m1._02 * m1._02));
		if(length){
			length = 1.0 / length; 
			m1._00 = m1._00 * length;
			m1._01 = m1._01 * length;
			m1._02 = m1._02 * length;
		}

		m1._20 = (m1._01 * m1._12) - (m1._02 * m1._11);
		m1._21 = (m1._02 * m1._10) - (m1._00 * m1._12);
		m1._22 = (m1._00 * m1._11) - (m1._01 * m1._10);

	}else{
		m1._10 = (m1._21 * m2._02) - (m1._22 * m2._01);
		m1._11 = (m1._22 * m2._00) - (m1._20 * m2._02);
		m1._12 = (m1._20 * m2._01) - (m1._21 * m2._00);

		length = Math.sqrt((m1._10 * m1._10) + (m1._11 * m1._11) + (m1._12 * m1._12));
		if(length){
			length = 1.0 / length; 
			m1._10 = m1._10 * length;
			m1._11 = m1._11 * length;
			m1._12 = m1._12 * length;
		}

		m1._00 = (m1._11 * m1._22) - (m1._12 * m1._21);
		m1._01 = (m1._12 * m1._20) - (m1._10 * m1._22);
		m1._02 = (m1._10 * m1._21) - (m1._11 * m1._20);
	}

	m1._30 = m2._30;
	m1._31 = m2._31;
	m1._32 = m2._32;
	
	return m1;
}