Flashゲーム講座 & アクションスクリプトサンプル集



単位行列を作成する

 
 


 
行列の型


4行3列のオブジェクトで管理しています。計算上は4行4列ですが4列目は使わないのでその分の処理を省いています。。

ここで扱うマトリックスの形式

  var 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(){
  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
  };
}
 
使用例です。

例)行列を作成する

  var matrix = Mtx44Create();
 

 




平行行列を作成する

 
 


 
平行行列生成

平行行列を作ります。

引数にオブジェクト型の3Dベクトル
戻り値に行列が返ります。

平行行列を作成

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
  };
}
 
例)x座標に 20 y座標に -7 z座標に 3 移動する行列

  var vec = {x:20,y:-7,z:3};
  var matrix = Mtx44Translate(vec);
 

 
平行行列 × 行列

平行行列を生成してから、別の行列の前に置いて乗算する関数です。

第01引数にオブジェクト型の3Dベクトル
第02引数に行列
戻り値に行列が返ります。

平行行列を別の行列の前に置いて乗算

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
  };
}
 
例)[(4,5,6)移動する行列] × [(1,2,3)移動する行列]

  var v1 = {x:1,y:2,z:3};
  var m1 = Mtx44Translate(v1);
  var v2 = {x:4,y:5,z:6};
  var m2 = Mtx44TranslatePref(v2,m1);
 

 
行列 × 平行行列

平行行列を生成してから、別の行列の後に置いて乗算する関数です。

第01引数にオブジェクト型の3Dベクトル
第02引数に行列
戻り値に行列が返ります。

平行行列を別の行列の後に置いて乗算

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
  };
}
 
例)[(1,2,3)移動する行列] × [(4,5,6)移動する行列]

  var v1 = {x:1,y:2,z:3};
  var m1 = Mtx44Translate(v1);
  var v2 = {x:4,y:5,z:6};
  var m2 = Mtx44TranslatePref(v2,m1);
 

 




X軸で回転する行列を作成する

 
 


 
X軸で回転する行列生成

第01引数に角度
戻り値に行列が返ります。

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軸で30度回転する行列


  var matrix = Mtx44RotateX(30);

  
 

 
回転行列 × 行列

回転行列を生成してから、別の行列の前に置いて乗算する関数です。

第01引数に角度
第02引数に行列
戻り値に行列が返ります。

回転行列を別の行列の前に置いて乗算

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
  };
}
 
例)[30 度回転する行列] × [(1,2,3)移動する行列]

  var v = {x:1,y:2,z:3};
  var m1 = Mtx44Translate(v);
  var m2 = Mtx44RotateXPref(30 ,m1);

  
 

 
行列 × 回転行列

回転行列を生成してから、別の行列の後に置いて乗算する関数です。

第01引数に角度
第02引数に行列
戻り値に行列が返ります。

回転行列を別の行列の後に置いて乗算

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
  };
}
 
例)[(1,2,3)移動する行列] × [30 度回転する行列]

  var v = {x:1,y:2,z:3};
  var m1 = Mtx44Translate(v);
  var m2 = Mtx44RotateXPost(30 ,m1);
 

 




Y軸で回転する行列を作成する

 
 


 
Y軸で回転する行列生成

第01引数に角度
戻り値に行列が返ります。

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軸で30度回転する行列

  var matrix = Mtx44RotateY(30);
 

 
回転行列 × 行列

回転行列を生成してから、別の行列の前に置いて乗算する関数です。

第01引数に角度
第02引数に行列
戻り値に行列が返ります。

回転行列を別の行列の前に置いて乗算

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
  };
}
 
例)[30 度回転する行列] × [(1,2,3)移動する行列]

  var v = {x:1,y:2,z:3};
  var m1 = Mtx44Translate(v);
  var m2 = Mtx44RotateYPref(30 ,m1);
 

 
行列 × 回転行列

回転行列を生成してから、別の行列の後に置いて乗算する関数です。

第01引数に角度
第02引数に行列
戻り値に行列が返ります。

回転行列を別の行列の後に置いて乗算

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
  };
}
 
例)[(1,2,3)移動する行列] × [30 度回転する行列]

  var v = {x:1,y:2,z:3};
  var m1 = Mtx44Translate(v);
  var m2 = Mtx44RotateYPost(30 ,m1);
 

 




Z軸で回転する行列を作成する

 
 


 
Z軸で回転する行列生成

第01引数に角度
戻り値に行列が返ります。

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軸で30度回転する行列

  var matrix = Mtx44RotateZ(30);
 

 
回転行列 × 行列

回転行列を生成してから、別の行列の前に置いて乗算する関数です。

第01引数に角度
第02引数に行列
戻り値に行列が返ります。

回転行列を別の行列の前に置いて乗算

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
  };
}
 
例)[30 度回転する行列] × [(1,2,3)移動する行列]

  var v = {x:1,y:2,z:3};
  var m1 = Mtx44Translate(v);
  var m2 = Mtx44RotateZPref(30 ,m1);
 

 
行列 × 回転行列

回転行列を生成してから、別の行列の後に置いて乗算する関数です。

第01引数に角度
第02引数に行列
戻り値に行列が返ります。

回転行列を別の行列の後に置いて乗算

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
  };
}
 
例)[(1,2,3)移動する行列] × [30 度回転する行列]

  var v = {x:1,y:2,z:3};
  var m1 = Mtx44Translate(v);
  var m2 = Mtx44RotateZPost(30 ,m1);
 

 




任意軸で回転する行列を作成する

 
 


 
任意軸で回転する行列生成

第01引数に回転軸を表す3Dベクトル
第02引数に角度
戻り値に行列が返ります。

任意軸で回転する行列を作成

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 }; }
 
例)任意軸(1,1,1)で30度回転する行列

  var vec = {x:1,y:1,z:1};
  var matrix = Mtx44Rotate(vec,30);
 

 
回転行列 × 行列

回転行列を生成してから、別の行列の前に置いて乗算する関数です。

第01引数に回転軸を表す3Dベクトル
第02引数に角度
第03引数に行列
戻り値に行列が返ります。

回転行列を別の行列の前に置いて乗算

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 }; }
 
例)[任意軸(1,1,1)で30度回転する行列] × [(1,2,3)移動する行列]

  var v1 = {x:1,y:2,z:3};
  var m1 = Mtx44Translate(v1);
   var v2 = {x:1,y:1,z:1};
  var m2 = Mtx44RotatePref(v2,30 ,m1);
 

 
行列 × 回転行列

回転行列を生成してから、別の行列の後に置いて乗算する関数です。

第01引数に回転軸を表す3Dベクトル
第02引数に角度
第03引数に行列
戻り値に行列が返ります。

回転行列を別の行列の後に置いて乗算

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 }; }
 
例)[(1,2,3)移動する行列] × [任意軸(1,1,1)で30度回転する行列]

  var v1 = {x:1,y:2,z:3};
  var m1 = Mtx44Translate(v1);
   var v2 = {x:1,y:1,z:1};
   var m2 = Mtx44RotatePost(v2 ,30 ,m1);
 

 




拡縮行列を作成する

 
 


 
拡縮行列生成

第01引数に倍率を表す3Dベクトル
戻り値に行列が返ります。

拡縮行列を作成

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
  };
}
 
例)x方向に 2 倍、y方向に 0.5 倍、z方向に 1.5 倍拡縮する行列

  var vec = {x:2,y:0.5,z:1.5};
  var matrix = Mtx44Scale(vec);
 

 
行列 × 拡縮行列

拡縮行列を生成してから、別の行列の前に置いて乗算する関数です。

第01引数に倍率を表す3Dベクトル
第02引数に行列
戻り値に行列が返ります。

拡縮行列を別の行列の前に置いて乗算

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
  };
}
 
例)[x方向に 2 倍、y方向に 0.5 倍、z方向に 1.5 倍拡縮する行列] × [30 度回転する行列]

  var m1 = Mtx44RotateX(30);
  var vec = {x:2,y:0.5,z:1.5};
  var m2 = Mtx44ScalePref(vec ,m1);
 

 
拡縮行列 × 行列

拡縮行列を生成してから、別の行列の後に置いて乗算する関数です。

第01引数に倍率を表す3Dベクトル
第02引数に行列
戻り値に行列が返ります。

拡縮行列を別の行列の後に置いて乗算

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
  };

}
 
例)[30 度回転する行列] × [x方向に 2 倍、y方向に 0.5 倍、z方向に 1.5 倍拡縮する行列]

  var m1 = Mtx44RotateX(30);
  var vec = {x:2,y:0.5,z:1.5};
  var m2 = Mtx44ScalePost(vec ,m1);
 

 




座標の射影変換

 
 


 
座標の射影変換

第01引数に位置を表す3Dベクトル
第02引数に行列
戻り値にオブジェクト形式の座標が返ります。

3D座標をマトリックスに射影する

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
  };
}
 
例)座標(1,2,3)を行列に射影した後の座標を求める

  var vec = {x:1,y:2,z:3};
  var m = Mtx44RotateX(30);  // 30度回転

  var pos = Vec3dTransformPoint(vec,m);
 

 




ベクトルの射影変換

 
 


 
ベクトルの射影変換

第01引数に方向を表す3Dベクトル
第02引数に行列
戻り値にオブジェクト形式のベクトルが返ります。

3Dベクトルをマトリックスに射影する

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
  };
};
 
例)ベクトル(1,2,3)を行列に射影した後のベクトルを求める

  var vec = {x:1,y:2,z:3};
  var m = Mtx44RotateX(30);  // 30度回転

  var pos = Vec3dTransformVector(vec,m);
 

 




マトリックスの射影変換

 
 


 
行列×行列の計算

第01引数に前に置く行列
第02引数に後に置く行列
戻り値に行列が返ります。

行列同士を乗算する

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 }; };
 
例)行列と行列の乗算

  var vec = {x:1,y:2,z:3};
  var m1 = Mtx44Scale(vec);     // スケーリング行列
  var m2 = Mtx44RotateX(30,m);   // 回転行列

  var m3 = Mtx44Transform(m1 ,m2);

 

 




正規直交行列の逆行列を作成する

 
 


 
正規直交行列の逆行列を作成する

第01引数に行列
戻り値に逆行列が返ります。

正規直交行列の逆行列を作成する

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)
  };
}
 
例)逆行列を求める

  var m1 = Mtx44RotateX(30);   // 30度回転
  var m2 = Mtx44InvertOrthoNormal(m1);
 

 




逆行列を作成する

 
 


 
逆行列を作成する

第01引数に行列
戻り値に逆行列が返ります。

逆行列を作成する

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;
}
 
例)逆行列を求める

  var m1 = Mtx44RotateX(30);   // 30度回転
  var m2 = Mtx44Invert(m1);
 

 




行列を正規直交化する

 
 


 
行列を正規直交化する

第01引数に行列
正規直交行列化された行列が返ります。

行列を正規直交化する

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; }
 
例)行列を正規直交化する

  var m1 = Mtx44RotateX(30);   // 30度回転
  var m2 = Mtx44OrthoNormalize(m1);
 

 




ソースをダウンロード

 
 





- 関数をまとめたソース -

mtx44.as(25kバイト)ActionScript ファイル