OSG 使用整理（3）：自定义漫游器动画

自定义漫游器动画

1 相机视图矩阵

1.1   坐标系统

 

（1）局部坐标系：以三维物体中的某个原点建立顶点比较方便，事实上一个复杂物体可能有多个局部坐标系，每个局部坐标系用于其某个部位。通过一组平移、旋转和缩放变换的组合，可以将局部坐标系变换到世界坐标系。

（2）世界坐标系：为了定义所有物体之间的空间关系，必须将这些物体变换到这个公共空间中。该变换由模型矩阵（Model Matrix）实现。

（3）摄像机/观察坐标系：观察坐标系就是从摄像机的视角所观察到的空间，而这通常是由一系列的位移和旋转的组合来完成，平移/旋转场景从而使得特定的对象被变换到摄像机的前方。这些组合在一起的变换通常储存在一个观察矩阵（View Matrix）中。

（4）标准化设备坐标系：定义一个投影矩阵(Projection Matrix)，它指定了一个范围的坐标，比如在每个维度上的-1000到1000。投影矩阵接着会将在这个指定的范围内的坐标变换为标准化设备坐标的范围(-1.0, 1.0)。所有在范围外的坐标不会被映射到在-1.0到1.0的范围之间，所以会被裁剪掉。

（5）屏幕坐标系：它的原点位于屏幕的坐上角，y 轴正向垂直向下。

在OpenGL中，本地坐标系、世界坐标系和观察坐标系都属于右手坐标系，而最终的裁剪坐标系和标准化设备坐标系属于左手坐标系。

1.2   视图矩阵（View Matrix）详细推导

观察坐标系中，场景中所有顶点坐标经过视图变换到了以摄像机为原点的观察坐标。要定义一个摄像机，需要指定它在世界坐标系上的位置、观察方向、向右和向上方向。将摄像机位置设为eye，朝向的点为lookAt，向上向量为up，创建一个以摄像机为原点的坐标系。

(1)   首先计算方向向量：

dir=(eye-lookAt).normalize()

(2) 然后根据向上向量和方向向量计算得到摄像机右向量：

right=cross(dir,up).normalize()

(3) 然后计算计算单位向上向量：

up=cross(dir,right).normalize()

我们将摄像机放到世界坐标系原点，朝向-z轴方向，向上方向与y轴方向重合，这时候相机坐标系就和世界坐标系重合。这个过程分成两个矩阵，一是把摄像机移动到原点的平移变换（Transform Matrix）,二是将摄像机的方向旋转变换（Rotate Matrix）到正确方向。

平移矩阵如下：

 

旋转逆矩阵中的各分量值即为x，y，z三个单位向量旋转后的值：

因为正交矩阵的逆等于转置，得到最终的视图矩阵：

1.1   OSG中视图矩阵

OSG提供osg::MatrixTransform类和osg::PositionAttitudeTransform子类改变节点的模型变换矩阵（Model Matrix）。另外提供了osg::Camera类计算相机视图矩阵（View Maatrix）,但实际上相机的视图矩阵是由查看器的内部osgGA::CameraManipulator对象进行控制的。

(1) View::setCameraManipulator方法new 一个漫游器对象。

(2) View::init方法中调用漫游器初始化虚函数init

void View::init()
{
    OSG_INFO<<"View::init()"<<std::endl;

    osg::ref_ptr<osgGA::GUIEventAdapter> initEvent = _eventQueue->createEvent();
    initEvent->setEventType(osgGA::GUIEventAdapter::FRAME);
 if (_cameraManipulator.valid())
    {
        _cameraManipulator->init(*initEvent, *this);
    }
}

(3) Viewer::eventTraversal方法事件遍历最后调用漫游器handle处理事件响应。

for(osgGA::EventQueue::Events::iterator itr = events.begin();itr != events.end();++itr)
{
        osgGA::Event* event = itr->get();
        if (event && _cameraManipulator.valid())
        {
            _cameraManipulator->handle( event, 0, _eventVisitor.get());
        }
}

(4) Viewer::updateTraversal方法更新遍历中调用漫游器updateCamera更新相机视图矩阵。

/** update the camera for the current frame, typically called by the viewer classes.
Default implementation simply set the camera view matrix. */
virtual void updateCamera(osg::Camera& camera) { camera.setViewMatrix(getInverseMatrix()); }

2 OSG漫游器

2.1 CameraManipulator虚基类

       osgGA:: CameraManipulator虚基类继承osgGA:: GUIEventHandler，以处理事件消息，为子类提供接口：

/** set the position of the matrix manipulator using a 4x4 Matrix.*/
virtual void setByMatrix(const osg::Matrixd& matrix) = 0;

/** set the position of the matrix manipulator using a 4x4 Matrix.*/
virtual void setByInverseMatrix(const osg::Matrixd& matrix) = 0;

/** get the position of the manipulator as 4x4 Matrix.*/
virtual osg::Matrixd getMatrix() const = 0;

/** get the position of the manipulator as a inverse matrix of the manipulator, typically used as a model view matrix.*/
virtual osg::Matrixd getInverseMatrix() const = 0;

/** Handle events, return true if handled, false otherwise. */
virtual bool handle(const GUIEventAdapter& ea,GUIActionAdapter& us);

2.2 StandardManipulator虚基类

　　osgGA:: StandardManipulator虚基类继承osgGA:: CameraManipulator，补充了设置计算视图矩阵的接口和初始化方法：

/** Sets manipulator by eye position and eye orientation.*/
virtual void setTransformation( const osg::Vec3d& eye, const osg::Quat& rotation ) = 0;

/** Sets manipulator by eye position, center of rotation, and up vector.*/
virtual void setTransformation( const osg::Vec3d& eye, const osg::Vec3d& center, const osg::Vec3d& up ) = 0;

/** Gets manipulator's eye position and eye orientation.*/
virtual void getTransformation( osg::Vec3d& eye, osg::Quat& rotation ) const = 0;

/** Gets manipulator's focal center, eye position, and up vector.*/
virtual void getTransformation( osg::Vec3d& eye, osg::Vec3d& center, osg::Vec3d& up ) const = 0;

virtual void init( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& us );

　　并且重写了事件响应handle方法，大概有刷新事件、窗口大小重置事件、鼠标事件、键盘事件等类型。

/** Handles events. Returns true if handled, false otherwise.*/
bool StandardManipulator::handle( const GUIEventAdapter& ea, GUIActionAdapter& us )
{
    switch( ea.getEventType() )
    {

        case GUIEventAdapter::FRAME:
            return handleFrame( ea, us );

        case GUIEventAdapter::RESIZE:
            return handleResize( ea, us );

        default:
            break;
   }

    if( ea.getHandled() )
        return false;

    switch( ea.getEventType() )
    {
        case GUIEventAdapter::MOVE:
            return handleMouseMove( ea, us );

        case GUIEventAdapter::DRAG:
            return handleMouseDrag( ea, us );

        case GUIEventAdapter::PUSH:
            return handleMousePush( ea, us );

        case GUIEventAdapter::RELEASE:
            return handleMouseRelease( ea, us );

        case GUIEventAdapter::KEYDOWN:
            return handleKeyDown( ea, us );

        case GUIEventAdapter::KEYUP:
            return handleKeyUp( ea, us );

        case GUIEventAdapter::SCROLL:
            if( _flags & PROCESS_MOUSE_WHEEL )
            return handleMouseWheel( ea, us );
            else
            return false;

        default:
            return false;
    }
}

　　事件处理函数内部只简单记录了当前时间和屏幕坐标，另外鼠标事件还调用了performMovement函数，细分了左中右键点击处理函数。

2.3 OrbitManipulator类

       osgGA:: OrbitManipulator类为轨道漫游器，可以使得相机围绕目标进行轨道运动，维护了目标中心（osg::Vec3d _center ）、旋转四元数（osg::Quat  _rotation）、相机距离（double     _distance）三个关键数据，类似于1.2节中过程可以由此推导出视图矩阵。最终返回的矩阵如下：

/** Get the position of the manipulator as a inverse matrix of the manipulator,
typically used as a model view matrix.*/
osg::Matrixd OrbitManipulator::getInverseMatrix() const
{
    return osg::Matrixd::translate( -_center ) *
           osg::Matrixd::rotate( _rotation.inverse() ) *
           osg::Matrixd::translate( 0.0, 0.0, -_distance );
}
// doc in parent
void OrbitManipulator::setTransformation( const osg::Vec3d& eye, const osg::Vec3d& center, const osg::Vec3d& up )
{
    Vec3d lv( center - eye );

    Vec3d f( lv );
    f.normalize();
    Vec3d s( f^up );
    s.normalize();
    Vec3d u( s^f );
    u.normalize();

    osg::Matrixd rotation_matrix( s[0], u[0], -f[0], 0.0f,
                            s[1], u[1], -f[1], 0.0f,
                            s[2], u[2], -f[2], 0.0f,
                            0.0f, 0.0f,  0.0f, 1.0f );

    _center = center;
    _distance = lv.length();
    _rotation = rotation_matrix.getRotate().inverse();

    // fix current rotation
    if( getVerticalAxisFixed() )
        fixVerticalAxis( _center, _rotation, true );
}

　　首先将漫游器移动到目标中心，然后旋转对齐方向向量，最后移动到观察位置。

　　osgGA:: OrbitManipulator类重载了鼠标事件处理方法，详细编写了左中右键点击时间处理。其中左键拖动鼠标默认以轨道方式绕着目标旋转漫游器，中键拖动鼠标默认在xy平面平移漫游器，右键拖动鼠标默认在z轴移动漫游器，来达到缩放效果。

　　综上分析，想要实现漫游器动画，需要重载函数修改目标中心、旋转四元数、相机距离这三个数据。

2.3 AnimationPathManipulator类

　　osgGA:: AnimationPathManipulator类继承osgGA:: CameraManipulator，其内部维护了私有变量动画路径osg::AnimationPath _animationPath。初始化方法中可以直接导入动画路径，也可以外部设置，动画路径_animationPath需要设置动画循环模式、开始结束时间、控制点。osgGA:: AnimationPathManipulator类重载了事件响应方法：

bool AnimationPathManipulator::handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& us)
{
    if( !valid() ) return false;

    switch( ea.getEventType() )
    {
    case GUIEventAdapter::FRAME:
        if( _isPaused )
        {
            handleFrame( _pauseTime );
        }
        else
        {
            handleFrame( ea.getTime() );
        }
        return false;
    case GUIEventAdapter::KEYDOWN:
            if (ea.getKey()==' ')
            {
                _isPaused = false;

                home(ea,us);
                us.requestRedraw();
                us.requestContinuousUpdate(false);

                return true;
            }
            else if (ea.getKey()==')')
            {
                double time = _isPaused ? _pauseTime : ea.getTime();
                double animationTime = (time+_timeOffset)*_timeScale;

                _timeScale *= 1.1;

                OSG_NOTICE<<"Animation speed = "<<_timeScale*100<<"%"<<std::endl;

                // adjust timeOffset so the current animationTime does change.
                _timeOffset = animationTime/_timeScale - time;

                return true;
            }
            else if (ea.getKey()=='(')
            {
                double time = _isPaused ? _pauseTime : ea.getTime();
                double animationTime = (time+_timeOffset)*_timeScale;

                _timeScale /= 1.1;

                OSG_NOTICE<<"Animation speed = "<<_timeScale*100<<"%"<<std::endl;

                // adjust timeOffset so the current animationTime does change.
                _timeOffset = animationTime/_timeScale - time;

                return true;
            }
            else if(ea.getKey() == 'p')
            {
                if( _isPaused )
                {
                    _isPaused = false;
                    _timeOffset -= ea.getTime() - _pauseTime;
                }
                else
                {
                    _isPaused = true;
                    _pauseTime = ea.getTime();
                }
                us.requestRedraw();
                us.requestContinuousUpdate(false);
                return true;
            }

        break;
        default:
            break;
    }
    return false;
}

　　handle方法中通过handleFrame更新视图矩阵。

void AnimationPathManipulator::handleFrame( double time )
{
    osg::AnimationPath::ControlPoint cp;

    double animTime = (time+_timeOffset)*_timeScale;
    _animationPath->getInterpolatedControlPoint( animTime, cp );

    if (_numOfFramesSinceStartOfTimedPeriod==-1)
    {
        _realStartOfTimedPeriod = time;
        _animStartOfTimedPeriod = animTime;

    }

    ++_numOfFramesSinceStartOfTimedPeriod;

    double animDelta = (animTime-_animStartOfTimedPeriod);
    if (animDelta>=_animationPath->getPeriod())
    {
        if (_animationCompletedCallback.valid())
        {
            _animationCompletedCallback->completed(this);
        }

        if (_printOutTimingInfo)
        {
            double delta = time-_realStartOfTimedPeriod;
            double frameRate = (double)_numOfFramesSinceStartOfTimedPeriod/delta;
            OSG_NOTICE <<"AnimatonPath completed in "<<delta<<" seconds, completing "<<_numOfFramesSinceStartOfTimedPeriod<<" frames, average frame rate = "<<frameRate<<std::endl;
        }

        // reset counters for next loop.
        _realStartOfTimedPeriod = time;
        _animStartOfTimedPeriod = animTime;
        _numOfFramesSinceStartOfTimedPeriod = 0;
    }

    cp.getMatrix( _matrix );
}

3 自定义OSG漫游器视角动画

3.1 四元数与三维旋转

       本篇论述引自Krasjet的博文re：https://krasjet.github.io/quaternion/quaternion.pdf，他从几何和计算机图形学角度上，介绍了四元数的概念和应用，详细讨论了四元数和三维旋转之间的关系。

(1)   定义：

(2)   四则运算：

　　加减法各分量相加减

　　标量乘法：乘以每一项

　　四元数乘法： 

 

 

 

(3)   3D旋转公式 

(4)   设单位四元数  

则它对应的旋转角度、旋转轴为 

θ/2=（cos）^(-1) (a)
u=V/(sin⁡(（cos）^(-1) (a)))

同一个3D旋转可以使用两个不同的四元数来表示，如果𝑞表示的是沿着旋转轴u旋转θ度，那么−𝑞代表的是沿着相反的旋转轴−u旋转(2𝜋 − θ)度。

(5)   slerp插值（球面线性插值，Spherical Linear Interpolation）

qt = Slerp(q0,q1,t) = sin((1 - t)θ) sin(θ) q0 + sin(tθ) sin(θ) q1

　　其中q0、q1之间的夹角可以直接使用它们的点乘的结果：。注意到插值时检查夹角是否过小，导致除零的问题。

3.2 缓动函数

　　re: https://easings.net/

　　缓动函数代表的是一个数学函数，这个数学函数描述动画期间一维值变化的速度。这让你在整个动画过程中改变动画的速度。

 

　　QT自带缓动函数类QEasingCurve，头文件qeasingcurve.h，使用如下：

QEasingCurve easing(QEasingCurve::InOutQuad);

for (qreal t = 0.0; t < 1.0; t += 0.1)
   qWarning() << "Effective progress" << t << "is"
             << easing.valueForProgress(t);

3.3 自定义漫游器视角动画

       结合上述理论，不使用osgGA:: AnimationPathManipulator类，也可以实现自定义漫游器视角动画，关键点：

       （1）继承osgGA:: OrbitManipulator类，重载GUIEventAdapter::FRAME:里面的刷新事件，更新旋转四元数（osg::Quat  _rotation）。

       （2）创建最终旋转状态四元数，设置坐标轴和旋转角，使用slerp插值，得到中间状态插值的四元数。

       （3）使用QT自带缓动函数，优化动画效果。设置动画执行时间、开始结束时间、缓动函数类型。