Форум Flasher.ru - Матрицы(векторы)

Вот пример поворота точки на произовольный угол, может поможет
Стандартный способ перемножения 7-ми матриц мне не подошел, т.к. если возникали частные случаи (ось поворота совпадала с коорд. осью) он не работал.

Код:

//модуль оси поворота

var wmod=_global.Math.sqrt(w[0]*w[0]+w[1]*w[1]+w[2]*w[2]);

//нормализация оси поворота

var axis=(wmod>0.001) ? [w[0]/wmod, w[1]/wmod, w[2]/wmod] : [0,0,1];

//расчет трансформы поворота вокруг произвольной оси

//содрано со статьи автора fowrel@yandex.ru, сайт не помню

//-------------------------------------------

//wmod - uгол поворота (назван так, пото мучто здесь это модуль угловой скорости

//axis - единичный вектор, символизирующий ось поворота

//o=[ox,oy,oz] - координаты начала вектора ахis

var angle=wmod*0.01;

var angleCos=Math.cos(angle), angleSin=Math.sin(angle);

var x=axis[0]*angleSin;

var y=axis[1]*angleSin;

var z=axis[2]*angleSin;

var w=angleCos;

var xx=x*x, xy=x*y, xz=x*z, xw=x*w;

var yy=y*y, yz=y*z, yw=y*w;

var zz=z*z, zw=z*w;

var W=[

        1 - 2*(yy+zz),                2*(xy-zw),                2*(xz+yw),                0,

        2*(xy+zw),        1 - 2*(xx+zz),                2*(yz-xw),                0,

        2*(xz-yw),                2*(yz+xw),        1 - 2*(xx+yy),                0,

        0,                                0,                                0,                1];

var F=[

        1,0,0,-o[0],

        0,1,0,-o[1],

        0,0,1,-o[2],

        0,0,0,1];

var F1=[

        1,0,0,o[0],

        0,1,0,o[1],

        0,0,1,o[2],

        0,0,0,1];

var t=mXm(mXm(F1,W),F);//конечная матрица поворота вокруг произвольной оси axis

//-------------------------------------------

//mXm-функция перемножения матриц

/*m1Xm0=function(m1, m0){

        return [

                m1[0]*m0[0] + m1[1]*m0[4] + m1[2]*m0[8] + m1[3]*m0[12],

                m1[0]*m0[1] + m1[1]*m0[5] + m1[2]*m0[9] + m1[3]*m0[13],

                m1[0]*m0[2] + m1[1]*m0[6] + m1[2]*m0[10] + m1[3]*m0[14],

                m1[0]*m0[3] + m1[1]*m0[7] + m1[2]*m0[11] + m1[3]*m0[15],



                m1[4]*m0[0] + m1[5]*m0[4] + m1[6]*m0[8] + m1[7]*m0[12],

                m1[4]*m0[1] + m1[5]*m0[5] + m1[6]*m0[9] + m1[7]*m0[13],

                m1[4]*m0[2] + m1[5]*m0[6] + m1[6]*m0[10] + m1[7]*m0[14],

                m1[4]*m0[3] + m1[5]*m0[7] + m1[6]*m0[11] + m1[7]*m0[15],



                m1[8]*m0[0] + m1[9]*m0[4] + m1[10]*m0[8] + m1[11]*m0[12],

                m1[8]*m0[1] + m1[9]*m0[5] + m1[10]*m0[9] + m1[11]*m0[13],

                m1[8]*m0[2] + m1[9]*m0[6] + m1[10]*m0[10] + m1[11]*m0[14],

                m1[8]*m0[3] + m1[9]*m0[7] + m1[10]*m0[11] + m1[11]*m0[15],



                m1[12]*m0[0] + m1[13]*m0[4] + m1[14]*m0[8] + m1[15]*m0[12],

                m1[12]*m0[1] + m1[13]*m0[5] + m1[14]*m0[9] + m1[15]*m0[13],

                m1[12]*m0[2] + m1[13]*m0[6] + m1[14]*m0[10] + m1[15]*m0[14],

                m1[12]*m0[3] + m1[13]*m0[7] + m1[14]*m0[11] + m1[15]*m0[15]];

};*/

Если требуется повернуть вокруг начала координат, удаляешь матрицы F и F1, тогда матрица W - конечная
P.S. Если верить fowrel@yandex.ru, то данная штука переделана с исходников Unreal Tournament