osg::QuaternionBase< ValueTypeT > Class Template Reference

00265     {
00266         Q_X = 0,
00267         Q_Y = 1,
00268         Q_Z = 2,
00269         Q_W = 3
00270     };

00092 {
00093     _quat[0] =
00094         _quat[1] =
00095         _quat[2] = TypeTraits<ValueTypeT>::getZeroElement();
00096 
00097     _quat[3] = TypeTraits<ValueTypeT>::getOneElement();
00098 }

00103 {
00104     for(UInt32 i = 0; i < 4; i++)
00105     {
00106         _quat[i] = source._quat[i];
00107     }
00108 }

00113 {
00114     setValue(matrix);
00115 }

00121 {
00122     setValueAsAxisRad(axis, angle);
00123 }

00130 {
00131     setValue(rotateFrom, rotateTo);
00132 }

00139 {
00140 }

00893 {
00894     bool returnValue = true;
00895 
00896     for(UInt32 i = 0; i < 4; i++)
00897     {
00898         returnValue &= ( (    _quat[i] - rot._quat[i] <= tolerance) &&
00899                          (rot._quat[i] -     _quat[i] <= tolerance));
00900     }
00901 
00902     return returnValue;
00903 }

00693 {
00694     getValuesOnly(matrix);
00695 
00696     matrix[0][3] = 0.0f;
00697     matrix[1][3] = 0.0f;
00698     matrix[2][3] = 0.0f;
00699 
00700     matrix[3][0] = 0.0f;
00701     matrix[3][1] = 0.0f;
00702     matrix[3][2] = 0.0f;
00703     matrix[3][3] = 1.0f;
00704 }

00676 {
00677   ValueTypeT x;
00678   ValueTypeT y;
00679   ValueTypeT z;
00680   ValueTypeT w;
00681 
00682   getValueAsAxisDeg(x, y, z, w);
00683 
00684   axis.setValues(x, y, z);
00685 
00686   degrees = w;
00687 }

00612 {
00613     ValueTypeT len;
00614 
00615     VectorType q(_quat[0], _quat[1], _quat[2]);
00616 
00617     len = q.length();
00618 
00619     if(len > Eps)
00620     {
00621         q *= (TypeTraits<ValueTypeT>::getOneElement() / len);
00622 
00623         x  = q[0];
00624         y  = q[1];
00625         z  = q[2];
00626 
00627         w = osgRad2Degree(2.0f * osgACos(_quat[3]));
00628     }
00629     else
00630     {
00631         x = TypeTraits<ValueTypeT>::getZeroElement();
00632         y = TypeTraits<ValueTypeT>::getZeroElement();
00633         z = TypeTraits<ValueTypeT>::getOneElement();
00634 
00635         w = TypeTraits<ValueTypeT>::getZeroElement();
00636     }
00637 }

00658 {
00659   ValueTypeT x;
00660   ValueTypeT y;
00661   ValueTypeT z;
00662   ValueTypeT w;
00663 
00664   getValueAsAxisRad(x, y, z, w);
00665 
00666   axis.setValues(x, y, z);
00667 
00668   radians = w;
00669 }

00597 {
00598     getValueAsAxisDeg(x, y, z, w);
00599 
00600     w = osgDegree2Rad(w);
00601 }

00646 {
00647     x = _quat[0];
00648     y = _quat[1];
00649     z = _quat[2];
00650     w = _quat[3];
00651 }

00584 {
00585     return _quat;
00586 }

00710 {
00711     matrix[0][0] = 1.0f - 2.0f * (_quat[Q_Y] * _quat[Q_Y] +
00712                                   _quat[Q_Z] * _quat[Q_Z]);
00713     matrix[0][1] =        2.0f * (_quat[Q_X] * _quat[Q_Y] +
00714                                   _quat[Q_Z] * _quat[Q_W]);
00715     matrix[0][2] =        2.0f * (_quat[Q_Z] * _quat[Q_X] -
00716                                   _quat[Q_Y] * _quat[Q_W]);
00717 
00718     matrix[1][0] =        2.0f * (_quat[Q_X] * _quat[Q_Y] -
00719                                   _quat[Q_Z] * _quat[Q_W]);
00720     matrix[1][1] = 1.0f - 2.0f * (_quat[Q_Z] * _quat[Q_Z] +
00721                                   _quat[Q_X] * _quat[Q_X]);
00722     matrix[1][2] =        2.0f * (_quat[Q_Y] * _quat[Q_Z] +
00723                                   _quat[Q_X] * _quat[Q_W]);
00724 
00725     matrix[2][0] =        2.0f * (_quat[Q_Z] * _quat[Q_X] +
00726                                   _quat[Q_Y] * _quat[Q_W]);
00727     matrix[2][1] =        2.0f * (_quat[Q_Y] * _quat[Q_Z] -
00728                                   _quat[Q_X] * _quat[Q_W]);
00729     matrix[2][2] = 1.0f - 2.0f * (_quat[Q_Y] * _quat[Q_Y] +
00730                                   _quat[Q_X] * _quat[Q_X]);
00731 }

00068 {
00069     return _identity;
00070 }

00808 {
00809     QuaternionBase returnValue(*this);
00810 
00811     returnValue.invert();
00812 
00813     return returnValue;
00814 }

00797 {
00798     _quat[0] = -_quat[0];
00799     _quat[1] = -_quat[1];
00800     _quat[2] = -_quat[2];
00801 //    _quat[3] =  _quat[3];
00802 }

00764 {
00765     return osgSqrt(_quat[0] * _quat[0] +
00766                    _quat[1] * _quat[1] +
00767                    _quat[2] * _quat[2] +
00768                    _quat[3] * _quat[3]);
00769 }

01038 {
01039     ValueTypeT s1, s2, s3, s4, s5, s6, s7, s8, s9, t;
01040 
01041     s1 = (rVal1[2] - rVal1[1]) * (rVal2[1] - rVal2[2]);
01042     s2 = (rVal1[3] + rVal1[0]) * (rVal2[3] + rVal2[0]);
01043     s3 = (rVal1[3] - rVal1[0]) * (rVal2[1] + rVal2[2]);
01044     s4 = (rVal1[2] + rVal1[1]) * (rVal2[3] - rVal2[0]);
01045     s5 = (rVal1[2] - rVal1[0]) * (rVal2[0] - rVal2[1]);
01046     s6 = (rVal1[2] + rVal1[0]) * (rVal2[0] + rVal2[1]);
01047     s7 = (rVal1[3] + rVal1[1]) * (rVal2[3] - rVal2[2]);
01048     s8 = (rVal1[3] - rVal1[1]) * (rVal2[3] + rVal2[2]);
01049 
01050     s9 = s6 + s7 + s8;
01051 
01052     t  = (s5 + s9) / 2.0f;
01053 
01054     _quat[3] = s1 + t - s6;
01055     _quat[0] = s2 + t - s9;
01056     _quat[1] = s3 + t - s8;
01057     _quat[2] = s4 + t - s7;
01058 
01059     normalize();
01060 }

00880 {
00881     mult(_quat, other._quat);
00882 }

00886 {
00887     mult(other._quat, _quat);
00888 }

00825 {
00826     ValueTypeT rx,ry,rz;
00827     ValueTypeT QwQx, QwQy, QwQz, QxQy, QxQz, QyQz;
00828     
00829     QwQx = _quat[3] * _quat[0]; 
00830     QwQy = _quat[3] * _quat[1]; 
00831     QwQz = _quat[3] * _quat[2];
00832     QxQy = _quat[0] * _quat[1]; 
00833     QxQz = _quat[0] * _quat[2]; 
00834     QyQz = _quat[1] * _quat[2];
00835     
00836     ValueTypeT Vx = src[0], Vy = src[1], Vz = src[2];
00837     
00838     rx = 2* (Vy * (-QwQz + QxQy) + Vz *( QwQy + QxQz));
00839     ry = 2* (Vx * ( QwQz + QxQy) + Vz *(-QwQx + QyQz));
00840     rz = 2* (Vx * (-QwQy + QxQz) + Vy *( QwQx + QyQz));
00841     
00842     ValueTypeT QwQw, QxQx, QyQy, QzQz;
00843 
00844     QwQw = _quat[3] * _quat[3]; 
00845     QxQx = _quat[0] * _quat[0]; 
00846     QyQy = _quat[1] * _quat[1]; 
00847     QzQz = _quat[2] * _quat[2];
00848 
00849     rx+= Vx * (QwQw + QxQx - QyQy - QzQz);
00850     ry+= Vy * (QwQw - QxQx + QyQy - QzQz);
00851     rz+= Vz * (QwQw - QxQx - QyQy + QzQz);
00852     
00853     dst.setValues(rx,ry,rz);
00854 }

00775 {
00776     ValueTypeT rLength = length();
00777 
00778     if(osgAbs(rLength) < Eps)
00779     {
00780         rLength =  TypeTraits<ValueTypeT>::getOneElement();
00781     }
00782     else
00783     {
00784         rLength =  TypeTraits<ValueTypeT>::getOneElement() / rLength;
00785     }
00786 
00787     for(UInt32 i = 0; i < 4; i++)
00788     {
00789         _quat[i] *= rLength;
00790     }
00791 }

00926 {
00927     mult(_quat, other._quat);
00928 }

00959 {
00960     return ! (*this == other);
00961 }

00936 {
00937     if (this == &source)
00938         return *this;
00939 
00940     for(UInt32 i = 0; i < 4; i++)
00941     {
00942         _quat[i] = source._quat[i];
00943     }
00944 
00945     return *this;
00946 }

00953 {
00954     return equals(other, Eps);
00955 }

00917 {
00918     return _quat[index];
00919 }

00910 {
00911     return _quat[index];
00912 }

00862 {
00863     VectorType axis;
00864     ValueTypeT radians;
00865 
00866     getValueAsAxisRad(axis, radians);
00867     setValueAsAxisRad(axis, radians * scaleFactor);
00868 }