如何修复怪异摄像头转动,同时与SDL在C移动相机时,OpenGL ++(How to fix wei

2019-10-17 06:13发布

我有我从阅读,处理前后移动网放在一起,扫射左,右,甚至用鼠标环顾四周的相机对象。 但是,当我向任何方向移动正试图寻找它周围跳所有的地方,但是当我不动,并环顾四周的罚款。

我希望有人能帮助我明白为什么我可以移动和四顾同一时间?

main.h

#include "SDL/SDL.h"
#include "SDL/SDL_opengl.h"

#include <cmath>


#define CAMERASPEED 0.03f               // The Camera Speed



struct tVector3 // Extended 3D Vector Struct

{           

tVector3() {} // Struct Constructor

tVector3 (float new_x, float new_y, float new_z) // Init Constructor     

{ x = new_x; y = new_y; z = new_z; }

// overload + operator

tVector3 operator+(tVector3 vVector) {return tVector3(vVector.x+x, vVector.y+y, vVector.z+z);}

// overload - operator

tVector3 operator-(tVector3 vVector) {return tVector3(x-vVector.x, y-vVector.y, z-vVector.z);}

// overload * operator

tVector3 operator*(float number)     {return tVector3(x*number, y*number, z*number);}

// overload / operator

tVector3 operator/(float number)     {return tVector3(x/number, y/number, z/number);}



float x, y, z;                      // 3D vector coordinates

};



class CCamera 

{

public:



    tVector3 mPos;  

    tVector3 mView;     

    tVector3 mUp;           



    void Strafe_Camera(float speed);



    void Move_Camera(float speed);

    void Rotate_View(float speed);
    void Position_Camera(float pos_x, float pos_y,float pos_z,

                         float view_x, float view_y, float view_z,

                         float up_x,   float up_y,   float up_z);

};



void Draw_Grid();

camera.cpp

#include "main.h"

void CCamera::Position_Camera(float pos_x, float pos_y, float pos_z,
                float view_x, float view_y, float view_z, 
                float up_x, float up_y, float up_z)
{
mPos = tVector3(pos_x, pos_y, pos_z);
mView = tVector3(view_x, view_y, view_z);
mUp = tVector3(up_x, up_y, up_z);
}

void CCamera::Move_Camera(float speed)
{
tVector3 vVector = mView - mPos;

mPos.x  = mPos.x  + vVector.x * speed;

mPos.z  = mPos.z  + vVector.z * speed;

mView.x = mView.x + vVector.x * speed;

mView.z = mView.z + vVector.z * speed;
}

void CCamera::Strafe_Camera(float speed)
{
tVector3 vVector = mView - mPos;

tVector3 vOrthoVector;



vOrthoVector.x = -vVector.z;

vOrthoVector.z =  vVector.x;



mPos.x  = mPos.x  + vOrthoVector.x * speed;

mPos.z  = mPos.z  + vOrthoVector.z * speed;

mView.x = mView.x + vOrthoVector.x * speed;

mView.z = mView.z + vOrthoVector.z * speed;
}

void CCamera::Rotate_View(float speed)
{
tVector3 vVector = mView - mPos;
tVector3 vOrthoVector;

vOrthoVector.x = -vVector.z;

vOrthoVector.z =  vVector.x;


mView.z = (float)(mPos.z + sin(speed)*vVector.x + cos(speed)*vVector.z);

mView.x = (float)(mPos.x + cos(speed)*vVector.x - sin(speed)*vVector.z);

}

和MOUSEMOTION码

void processEvents()
{
int mid_x = screen_width  >> 1;

int mid_y = screen_height >> 1;
int mpx = event.motion.x;
int mpy = event.motion.y;

float angle_y  = 0.0f;

float angle_z  = 0.0f;

while(SDL_PollEvent(&event))
{
    switch(event.type)
    {
        case SDL_MOUSEMOTION:
            if( (mpx == mid_x) && (mpy == mid_y) ) return;



            // Get the direction from the mouse cursor, set a resonable maneuvering speed

            angle_y = (float)( (mid_x - mpx) ) / 1000; //1000

            angle_z = (float)( (mid_y - mpy) ) / 1000; //1000


            // The higher the value is the faster the camera looks around.

            objCamera.mView.y += angle_z * 2;



            // limit the rotation around the x-axis

            if((objCamera.mView.y - objCamera.mPos.y) > 8)  objCamera.mView.y = objCamera.mPos.y + 8;

            if((objCamera.mView.y - objCamera.mPos.y) <-8)  objCamera.mView.y = objCamera.mPos.y - 8;


            objCamera.Rotate_View(-angle_y);
            SDL_WarpMouse(mid_x, mid_y);
            break;

        case SDL_KEYUP:
            objKeyb.handleKeyboardEvent(event,true);
            break;
        case SDL_KEYDOWN:
            objKeyb.handleKeyboardEvent(event,false);
            break;

        case SDL_QUIT:
            quit = true;
            break;

        case SDL_VIDEORESIZE:
            screen = SDL_SetVideoMode( event.resize.w, event.resize.h, screen_bpp, SDL_OPENGL | SDL_HWSURFACE | SDL_RESIZABLE | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE );
            screen_width = event.resize.w;
            screen_height = event.resize.h;
            init_opengl();
            std::cout << "Resized to width: " << event.resize.w << " height: " << event.resize.h << std::endl;
            break;

        default:
            break;
    }
}
}

Answer 1:

我不完全相信你在上面做什么。

就个人而言,我只想让一个简单的4x4矩阵。 任何执行就行了。 要旋转你的,只是,需要使用鼠标x的变化和y为欧拉输入旋转绕Y旋转轴和x轴。 有很多的可用遍,会为你做这个网络代码。

其中一些矩阵库将不会为您提供“MoveForward()”函数。 如果是这样的话它的确定,前进是相当容易的。 第三列(或行,如果你使用的是一排大矩阵)是你的向前向量。 解压缩。 它正常化(这真的应该反正规格化,因此可能不需要这一步)。 通过你想多少前进,然后将其添加到位置(第4行/列)相乘。

现在,这里是奇数部分。 视图矩阵是一种特殊类型的矩阵。 上面的矩阵定义视图空间。 如果通过这个矩阵乘以当前的模型矩阵,你不会得到你所期望的答案。 因为要改造它,使得摄像机在原点。 因此,你需要,有效,撤消相机转型重新定位的东西上面定义的视图。 要做到这一点,你通过观察矩阵的乘以你的模型矩阵。

你现在有正确的视觉空间中定义的对象。

这是我最简单的相机类。 它不处理你所描述的功能,但希望会给你如何设置类的一些想法(但是请注意,我用的排大,即DirectX的风格,矩阵)。

BaseCamera.h:

#ifndef BASE_CAMERA_H_
#define BASE_CAMERA_H_

/*+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+*/

#include "Maths/Vector4.h"
#include "Maths/Matrix4x4.h"

/*+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+*/

class BaseCamera
{
protected:
    bool                    mDirty;
    MathsLib::Matrix4x4     mCameraMat;
    MathsLib::Matrix4x4     mViewMat;
public:
    BaseCamera();
    BaseCamera( const BaseCamera& camera );
    BaseCamera( const MathsLib::Vector4& vPos, const MathsLib::Vector4& vLookAt );
    BaseCamera( const MathsLib::Matrix4x4& matCamera );

    bool IsDirty() const;
    void SetDirty();

    MathsLib::Matrix4x4&        GetOrientationMatrix();
    const MathsLib::Matrix4x4&  GetOrientationMatrix() const;

    MathsLib::Matrix4x4&        GetViewMatrix();
};

/*+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+*/

inline MathsLib::Matrix4x4& BaseCamera::GetOrientationMatrix()
{
    return mCameraMat;
}

/*+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+*/

inline const MathsLib::Matrix4x4& BaseCamera::GetOrientationMatrix() const
{
    return mCameraMat;
}

/*+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+*/

inline bool BaseCamera::IsDirty() const
{
    return mDirty;
}

/*+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+*/

inline void BaseCamera::SetDirty()
{
    mDirty = true;
}

/*+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+*/

#endif

BaseCamera.cpp:

#include "Render/stdafx.h"

#include "BaseCamera.h"

/*+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+*/

BaseCamera::BaseCamera() :
    mDirty( true )
{
}

/*+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+*/

BaseCamera::BaseCamera( const BaseCamera& camera ) :
    mDirty( camera.mDirty ),
    mCameraMat( camera.mCameraMat ),
    mViewMat( camera.mViewMat )
{
}

/*+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+*/

BaseCamera::BaseCamera( const MathsLib::Vector4& vPos, const MathsLib::Vector4& vLookAt ) :
    mDirty( true )
{
    MathsLib::Vector4 vDir  = (vLookAt - vPos).Normalise();
    MathsLib::Vector4 vLat  = MathsLib::CrossProduct( MathsLib::Vector4( 0.0f, 1.0f, 0.0f ), vDir ).Normalise();
    MathsLib::Vector4 vUp   = MathsLib::CrossProduct( vDir, vLat );//.Normalise();

    mCameraMat.Set( vLat, vUp, vDir, vPos );    
}

/*+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+*/

BaseCamera::BaseCamera( const MathsLib::Matrix4x4& matCamera ) :
    mDirty( true ),
    mCameraMat( matCamera )
{
}

    /*+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+*/

MathsLib::Matrix4x4& BaseCamera::GetViewMatrix()
{
    if ( IsDirty() )
    {
        mViewMat    = mCameraMat.Inverse();
        mDirty      = false;
    }
    return mViewMat;
}

/*+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+*/


Answer 2:

我同意戈兹贝达。 您需要使用homegenous 4X4矩阵 ,如果你要代表仿射变换,如旋转+翻译

假设行主要表现那么如果没有脱屑或剪切,你的4x4矩阵表示如下:
行0至2:本地坐标系统的三个基本向量(即,X,Y,Z)
第3行:从原点当前翻译

因此,要沿着你的本地X矢量移动,如戈兹说,因为你可以假定它是一个单位向量,如果没有规模/剪切你刚才的举动一步乘以(+已经或-ve)然后添加合成矢量到行4矩阵因此,采取在开始设置为世界坐标系本地帧起源的一个简单的例子,然后你的矩阵会是这个样子

1 0 0 0 <--- x单位矢量
0 1 0 0 <---ÿ单位矢量
0 0 1 0 <--- z单位矢量
0 0 0 1 <---平移矢量

在某种程度上大多数游戏摄像机的工作方面,则轴映射是这样的:
x轴<=>相机潘左/右
Y轴<=>摄像头摇摄向上/向下
Z轴<=>相机放大/缩小

所以,如果我旋转我的参照整个帧说看一个新的起点注视那么作为戈兹贝达把他BaseCamera重载构造函数的代码,你再建一个新的局部坐标系,并设置该到你的矩阵(所有mCameraMat.Set( vLat, vUp, vDir, vPos )并通常被设定的矩阵即那些四行VLAT将是行0,VUP行1,行VDIR 2和VPOS行3)

然后放大/缩小只想成为排3 =第2 * stepval

同样作为戈兹贝达,正确地指出,你则需要将这一回世界空间,这是通过观察矩阵的倒数乘以完成



文章来源: How to fix weird camera rotation while moving camera with sdl, opengl in c++