/// В действительно этот код дает инвертированный кватернион (-x, -y, -z, w),
/// т.к. наши матрицы хранятся транспонироваными
/// CQuaternion::getMatrix3 работает  аналогично, так что все в порядке
CQuaternion CMatrix4::quaternion() const
{
    CQuaternion quat;
    F32     tr, s, q[4];
    U32     i, j, k;
    U32     nxt[3] = {1, 2, 0};

    // след матрицы
    tr = mMatrix[0][0] + mMatrix[1][1] + mMatrix[2][2];

    if (tr > 0.f)
    {
        s = (F32)sqrt (tr + 1.f);
        quat.mQ[VS] = s / 2.f;
        s = 0.5f / s;
        quat.mQ[VX] = (mMatrix[1][2] - mMatrix[2][1]) * s;
        quat.mQ[VY] = (mMatrix[2][0] - mMatrix[0][2]) * s;
        quat.mQ[VZ] = (mMatrix[0][1] - mMatrix[1][0]) * s;
    }
    else
    {
        i = 0;
        if (mMatrix[1][1] > mMatrix[0][0])
            i = 1;
        if (mMatrix[2][2] > mMatrix[i][i])
            i = 2;

        j = nxt[i];
        k = nxt[j];


        s = (F32)sqrt ((mMatrix[i][i] - (mMatrix[j][j] + mMatrix[k][k])) + 1.f);

        q[i] = s * 0.5f;

        if (s != 0.f)
            s = 0.5f / s;

        q[VS] = (mMatrix[j][k] - mMatrix[k][j]) * s;
        q[j] = (mMatrix[i][j] + mMatrix[j][i]) * s;
        q[k] = (mMatrix[i][k] + mMatrix[k][i]) * s;

        quat.set(q);
    }
    return quat;
}


//....
CMatrix4    CQuaternion::getMatrix4(void) const
{
    CMatrix4    mat;
    F32     xx, xy, xz, xw, yy, yz, yw, zz, zw;

    xx      = mQ[VX] * mQ[VX];
    xy      = mQ[VX] * mQ[VY];
    xz      = mQ[VX] * mQ[VZ];
    xw      = mQ[VX] * mQ[VW];

    yy      = mQ[VY] * mQ[VY];
    yz      = mQ[VY] * mQ[VZ];
    yw      = mQ[VY] * mQ[VW];

    zz      = mQ[VZ] * mQ[VZ];
    zw      = mQ[VZ] * mQ[VW];

    mat.mMatrix[0][0]  = 1.f - 2.f * ( yy + zz );
    mat.mMatrix[0][1]  =       2.f * ( xy + zw );
    mat.mMatrix[0][2]  =       2.f * ( xz - yw );

    mat.mMatrix[1][0]  =       2.f * ( xy - zw );
    mat.mMatrix[1][1]  = 1.f - 2.f * ( xx + zz );
    mat.mMatrix[1][2]  =       2.f * ( yz + xw );

    mat.mMatrix[2][0]  =       2.f * ( xz + yw );
    mat.mMatrix[2][1]  =       2.f * ( yz - xw );
    mat.mMatrix[2][2]  = 1.f - 2.f * ( xx + yy );

    // TODO -- should we set the translation portion to zero?

    return mat;
}

// очень простая интерполяция, t = 0...1.f
CQuaternion lerp(F32 t, const CQuaternion &p, const CQuaternion &q)
{
    CQuaternion r;
    F32 inv_t;

    inv_t = 1.f - t;

    r.mQ[VX] = t * q.mQ[VX] + (inv_t * p.mQ[VX]);
    r.mQ[VY] = t * q.mQ[VY] + (inv_t * p.mQ[VY]);
    r.mQ[VZ] = t * q.mQ[VZ] + (inv_t * p.mQ[VZ]);
    r.mQ[VW] = t * q.mQ[VW] + (inv_t * p.mQ[VW]);
    r.normalize();
    return r;
}