求解一个处理旋转的原理！

18615753501

操作形式:旋转一个方块

class Cube
{
public:
        enum RollType
        {
                NoRoll = 0,
                Roll_Front,
                Roll_Back,
                Roll_Left,
                Roll_Right
        };

        Cube(IDirect3DDevice9* device,int cellspace);
        ~Cube();
        void update(float timeDelta);
        bool draw(IDirect3DTexture9* tex[]);
        void roll_left_right(float angle);
        void roll_front_back(float angle);
        inline void SetRollType(RollType type)
        {
                _type = type;
        }
        inline RollType GetRollType()
        {
                return _type;
        }
private:
        void GetMatrix(D3DXMATRIX* world);
private:
        IDirect3DDevice9*       _device;
        ID3DXMesh*   _Mesh;
        D3DXVECTOR3 _right;
        D3DXVECTOR3 _up;
        D3DXVECTOR3 _look;
        RollType _type;
        float _timer;
};

void Cube::roll_left_right(float angle)
{
        D3DXMATRIX T;
        D3DXMatrixRotationAxis(&T, &_look,        angle);

        D3DXVec3TransformCoord(&_right,&_right, &T);
        D3DXVec3TransformCoord(&_up,&_up, &T);
}

void Cube::roll_front_back(float angle)
{
        D3DXMATRIX T;
        D3DXMatrixRotationAxis(&T, &_right,        angle);

        D3DXVec3TransformCoord(&_up,&_up, &T);
        D3DXVec3TransformCoord(&_look,&_look, &T);
}

void Cube::update(float timeDelta)
{
        if(_type == NoRoll)
                return;
        _timer += timeDelta*MaxAngle;
        if(_timer >= MaxAngle)
        {
                _timer = 0;
                _type = NoRoll;
        }
        if(_type == Roll_Front)
        {
                roll_front_back(-timeDelta*MaxAngle);
        }
        else if(_type == Roll_Back)
        {
                roll_front_back(timeDelta*MaxAngle);
        }
        else if(_type == Roll_Left)
        {
                roll_left_right(-timeDelta*MaxAngle);
        }
        else if(_type == Roll_Right)
        {
                roll_left_right(timeDelta*MaxAngle);
        }
}

void Cube::GetMatrix(D3DXMATRIX* mat)
{
        D3DXVec3Normalize(&_look, &_look);

        D3DXVec3Cross(&_up, &_look, &_right);
        D3DXVec3Normalize(&_up, &_up);

        D3DXVec3Cross(&_right, &_up, &_look);
        D3DXVec3Normalize(&_right, &_right);

        float x = 0;
        float y = 0;
        float z = 0;

        (*mat)(0,0) = _right.x; (*mat)(0, 1) = _up.x; (*mat)(0, 2) = _look.x; (*mat)(0, 3) = 0.0f;
        (*mat)(1,0) = _right.y; (*mat)(1, 1) = _up.y; (*mat)(1, 2) = _look.y; (*mat)(1, 3) = 0.0f;
        (*mat)(2,0) = _right.z; (*mat)(2, 1) = _up.z; (*mat)(2, 2) = _look.z; (*mat)(2, 3) = 0.0f;
        (*mat)(3,0) = x;        (*mat)(3, 1) = y;     (*mat)(3, 2) = z;       (*mat)(3, 3) = 1.0f;
}

操作方式:
if( ::GetAsyncKeyState(VK_UP) & 0x8000f&&!cube->GetRollType())
                cube->SetRollType(Cube::RollType::Roll_Front);
        if( ::GetAsyncKeyState(VK_DOWN) & 0x8000f&&!cube->GetRollType())
                cube->SetRollType(Cube::RollType::Roll_Back);
        if( ::GetAsyncKeyState(VK_LEFT) & 0x8000f&&!cube->GetRollType())
                cube->SetRollType(Cube::RollType::Roll_Left);
        if( ::GetAsyncKeyState(VK_RIGHT) & 0x8000f&&!cube->GetRollType())
                cube->SetRollType(Cube::RollType::Roll_Right);