四元数

a*quaternion   四元数quaternion   从（弧度m，轴v）获得 表示将a绕轴v旋转m得到的。。。

 

quaternion   *vector3  

   　　若vector3是个表示位移的向量 pos+=quaternion   *vector3  quaternion表示朝向orientation

　　　　表示 vector3这个位移是被挪到朝向上了  这个v3本身是一个经过坐标原点的向量

 

 

  通过四元数旋转一个Vector quaternion*vector

 // 通过四元数旋转一个vector

// 当Vector表示一个位移时,.
      // 结果表示,将vector转化为相对于mOrientation方向上的位移.

// 当Vector表示一个方向时,
     //表示将这个方向按照quat对应的旋转进行转,得到新的方向.

应用:
// 表示位移时
    void Node::translate(const Vector3& d, TransformSpace relativeTo)
    {
        Vector3 adjusted;
        switch(relativeTo)
        {
        case TS_LOCAL:
            // position is relative to parent so transform downwards
            mPosition += mOrientation * d;
         break;
    }

// 表示方向时:
// UNIT_X是机器人的默认正面朝向,即面向正X轴
// mNode是挂接robot的结点
// src运算的结果就是,结果渲染出来后机器人的面对的方向.(是一个3维向量)
Vector3 src = mNode->getOrientation( ) * Vector3::UNIT_X;   
// 计算出想要把机器人在屏幕上显示的朝向转向我们期望的朝向所用到的quat.
Ogre::Quaternion quat = src.getRotationTo( mDirection );
mNode->rotate( quat );

// :quat*vector3的算法实现.
    Vector3 Quaternion::operator* (const Vector3& v) const
    {
  // nVidia SDK implementation
  Vector3 uv, uuv;
  Vector3 qvec(x, y, z);
  uv = qvec.crossProduct(v);
  uuv = qvec.crossProduct(uv);
  uv *= (2.0f * w);
  uuv *= 2.0f;

  return v + uv + uuv;
} 

 

 

 OGRE的空间变换,translate()的陷阱! 

OGRE的空间变换,对于新手来说是一个头疼的问题,而其中的陷阱也是一堆一堆,即使我已经爬出这些陷阱,我还是觉得有必要讲一下.

translate()这个神秘的函数.网上发现一个朋友中了陷阱:

以下黑体字为论坛某个网友的错误理解:

----------------------------------------------------------------------------------------------------------------------------------

在CSDN和gameres上都发了这个问题，一直没人解答，不知道这儿怎么样？
void createScene() { 
... //第一个物体(坐标原点)  
Entity* head = mSceneMgr->createEntity("object1", "ogrehead.mesh");   
head->setMaterialName("Examples/Rockwall"); 
SceneNode* node1 = rootNode->createChildSceneNode();
node1->attachObject(head);

//第二个物体 
head = mSceneMgr->createEntity("object2", "ogrehead.mesh"); 
SceneNode* node2 = node1->createChildSceneNode(); 
node2->attachObject(head); 
node2->translate(Vector3(50, 0, 0), SceneNode::TS_PARENT); 

//第三个物体 
head = mSceneMgr->createEntity("object3", "ogrehead.mesh");
SceneNode* node3 = node2->createChildSceneNode(); 
node3->attachObject(head);
node3->translate(Vector3(0, 50, 0), SceneNode::TS_WORLD); 
node3->yaw(Degree(90), SceneNode::TS_LOCAL); 
}
按照空间变换分析，node1在原点，node2的世界坐标是(50, 0, 0)，node3的世界坐标是(0, 50, 0)，
但是从显示的结果来看node3是(50, 50, 0)，
无论用哪个TransformSpace值，结果都是一样的：translate都是相对于parent，旋转都是在loacal中。

 

我对这个参数的理解是：
TS_WORLD：不管当前节点是在哪个节点下，他的操作都是相对于世界坐标系的原点的。
    如node3是在node2下面，所以他的初始世界坐标应该是(50,0,0)，
    如果它translate(Vector3(0, 50, 0), SceneNode::TS_LOCAL)， 世界坐标应该是(50, 50, 0)
    如果它translate(Vector3(0, 50, 0), SceneNode::TS_WORLD)， 相对于世界坐标原点的平移，世界坐标应该是(0, 50, 0)

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

这个网友遇到的问题,其实就是translate变换的问题,为什么他会这么理解,我们慢慢分析:

 

translate()这个函数,其实是相对于父节点的相对移动,而不是那个网友理解的绝对移动.

但是如果是相对于父节点的相对移动,还要选择3个参考空间干嘛???

这就是关键所在,这3个参考空间,是决定相对移动量的方向的,而不是那个网友理解成的移动的位置!!!

为什么他的代码中的第3个节点无论怎么改变参考空间结果都一样?如果理解成方向,就豁然开朗了.
因为世界原点,父节点,他本身,这3个节点的面向的方向都是一样的(默认-Z方向),所以相对移动的值是一样,都是Y方向相对移动50

如果世界原点,父节点都是默认面向Z正方向,本身节点旋转90度面向Y的方向
如果他在本地空间translate(Vector3(0, 50, 0),SceneNode::TS_LOCAL),
因为他本身朝向Y, 在本地空间Y方向移动50, 在世界空间,其实就是-Z方向移动了50.

一句话:都是相对父节点移动50单位,而参考空间只是决定这50个单位移动的方向!

所以参考空间理解成朝向,就对了
世界空间----------认定世界原点的朝向为标准朝向,默认-Z方向
父节点空间----------认定父节点的朝向为标准朝向
本地空间--------------认定本身节点的朝向为标准朝向

 

那个网友的理解,其实合情合理,他的理解其实就是下面假想的函数:

setPosition(TS_WORLD); 
setPosition(TS_PARENT); 
setPosition(TS_LOCAL);

可惜这只是假想,设置位置的函数并没有参考空间可以选~~~

OGRE为什么不设置这样的函数呢?因为其实已经有替代的函数了: 
setPosition()   // 相对父空间坐标

setDerivedPosition()  // 世界空间绝对坐标

而本地空间的设置位置函数根本不需要.... 

 

最后,回头一想,为什么容易把translate()理解错....原因就是translate(TS_PARENT)相对父空间移动
的时候,如果把参考空间父空间理解成方向或者位置,2种情况下结果是正好是一样的,巧合啊
就是这种巧合,暗藏了一个陷进,让很多人认为理解成位置正好是对的...

不信看源码:

 

 

//-----------------------------------------------------------------------
void Node::translate(const Vector3& d, TransformSpace relativeTo)
{
    switch(relativeTo)
    {
    case TS_LOCAL:
        // position is relative to parent so transform downwards
        mPosition += mOrientation * d;
        break;
    case TS_WORLD:
        // position is relative to parent so transform upwards
        if (mParent)
        {
            mPosition += (mParent->_getDerivedOrientation().Inverse() * d)
                / mParent->_getDerivedScale();
        }
        else
        {
            mPosition += d;
        }
        break;
    case TS_PARENT:
        mPosition += d;
        break;
    }
    needUpdate();
}

 

 

 

 

因为mPosition相对于父节点的位置和方向,

所以计算结果都要换算成父空间相加.

 

本地空间,朝本身节点的朝向移动d,换到mPosition的所在的父空间只需要旋转一定角度,

这个角度应该是本身节点方向和父节点的方向的夹角,正好是mOrientation

mPosition += mOrientation * d;

 

世界空间,朝世界原点的朝向移动d ,换到mPosition的所在父空间只需要旋转一定角度,

这个角度应该是世界原点方向和父节点的方向的夹角,正好是父节点世界绝对角度再取反.

(为什么要取反,2个四元数相乘是不能交换的,因为世界节点和父节点夹角 != 父节点和世界节点夹角,正好相反)

       mPosition += (mParent->_getDerivedOrientation().Inverse() * d)
                    / mParent->_getDerivedScale();

 

父节点空间,朝父节点的朝向移动d ,换到mPosition的所在父空间只需要旋转一定角度,

父空间转到父空间....其实角度就是一致的

应该是mPosition += Quaternion::IDENTITY * d;

等价于mPosition +=  d;

子节点位于（0，3，0） 父节点位于（0，0，0）

translate(Vector3(0, 50, 0), SceneNode::TS_LOCAL)的意思是 相对于父节点移动Vector3(0, 50, 0)

子节点pos是（）
translate(Vector3(0, 50, 0), SceneNode::TS_PARENT)的意思是 相对于父节点移动Vector3(0, 50, 0)

translate(Vector3(0, 50, 0), SceneNode::TS_WORLD)的意思是 相对于父节点移动Vector3(0, 50, 0)

人类最初用9个值的矩阵（Matrix），来表示一个三维物体的旋转位置。它的缺陷是数据大，和无法自动在两个角度间产生过度的角度。

由于矩阵描述角度过于抽象，人类又发明了3个值的优拉角（Euler）。可优拉角是个很不负责任的家伙，旋转圈数和旋转顺序完全不做区分。三维动画师最厌 恶的情况之一‘万向锁（Gimbal Lock）’就是这个家伙的问题。按不同轴以优拉角旋转几次后，出现x,y,z三个轴完全变成同向的情况，也就是说，优拉角很容易出现旋转到最后只剩一个 方向可以旋转的情况，这就是恐怖的‘万向锁’。

后来，聪明的爱尔兰数学家发明了我们今天要研究的四元数（Quaternion），这就是迄今为止描述三维空间旋转相对完美的方案。

四元数和矩阵一样，不满足乘法交换率，也就是说，A*B不等于B*A。四元数之所以可以明确地表述三维旋转，是因为他实际上是一种‘四维’的算法。这里的‘四维’是数学上的使用，不需要去想象什么是四维的世界=_=,只是多一条轴，多一个参数而已。

我们主要介绍PV3d里Quaternion常用的几个方法和其用法，不会涉及过深的数学知识，所以不用担心。Quaternion类位置在org-papervision-core-math包里。

//构造四元数需要4个值（人家名字就叫4元嘛=_=）,x,y,z是个三维向量，表示‘任意轴’，w是个标量，表示旋转度数。这就是几乎完美的角度旋转。
四元数之所以不是‘绝对完美’，是因为插值的时候过渡速率不恒定，且很难解决。不过这比起‘恐怖万向锁’已经是很小的问题。

public function Quaternion( x:Number = 0, y:Number = 0, z:Number = 0, w:Number = 1 )

//下面两个个分别是‘从优拉角换算出四元数’和‘从矩阵换算出四元数’。这是两个非常常用的方法，只要已知一个物体的优拉角或矩阵，即可生成对应的四元数。
Pv3d里任何DisplayObject3D的tranform这个属性就是变换他的矩阵，由这个矩阵就能得到目前旋转的四元数。（我们研究所的Flab摄像机旋转就用到了这些方法）

public static function createFromEuler( ax:Number, ay:Number, az:Number, useDegrees:Boolean = false )
public static function createFromMatrix( matrix:Matrix3D )

//和上面的刚好反向，分别是‘得到已知四元数的优拉角’和‘得到已知四元数的矩阵’

public function toEuler()
public function get matrix()

//插值是四元数最重要的用处之一，slerp方法的参数中，qa为开始的旋转位置的四元数，qb为结束的旋转位置四元数，apha可以看成一个插值的位置的比例，数值在0-1之间。

public static function slerp( qa:Quaternion, qb:Quaternion, alpha:Number )

完美旋转的思路是这样的：
我们必须要首先知道我们的开始位置和结束位置，结束位置很多情况用一个DisplayObject3D虚拟，我们可以用它的.tranform（是个矩阵值），变换成一个四元数
知道两头的四元数，我们只需要每祯增加alpha值（从0-1），即可在这两个四元数之间插入任意多的过渡帧的四元数。
然后将每祯的这个四元数反向为矩阵，在通过矩阵相乘目前物体的位置，即可得到物体每祯的新位置。

下面这些都是四元数的基本运算（一般使用没必要掌握），维基词典可以了解‘四元数’更专业的解释。
维基词典-四元数（会打开新窗口）

//求模，四元数到原点的距离，简单的说就是长度
public function get modulo()

//共轨

public static function conjugate( a:Quaternion )

//点乘

public static function dot( a:Quaternion, b:Quaternion )

//叉称
public static function multiply( a:Quaternion, b:Quaternion )

//求差
public static function sub(a:Quaternion, b:Quaternion)

//求和
public static function add(a:Quaternion, b:Quaternion)