C++ 如何用c+中的sdl和opengl修复移动相机时奇怪的相机旋转+；

我有一个摄像头对象，是我在网上阅读时拼凑起来的，可以前后移动，左右扫射，甚至可以用鼠标环视四周。但当我朝任何方向移动，并试图环顾四周时，它会跳得到处都是，但当我不移动并环顾四周时，它会很好

我希望有人能帮我弄明白为什么我可以一边走动一边四处看看

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();

还有情绪密码

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;
    }
}
}

void processEvents（）
{
int mid_x=屏幕宽度>>1；
int mid_y=屏幕高度>>1；
int mpx=event.motion.x；
int-mpy=event.motion.y；
浮动角度_y=0.0f；
浮动角度_z=0.0f；
while（SDL_事件和事件））
{
开关（事件类型）
{
案例SDL_：
if（（mpx==mid_x）和&（mpy==mid_y））返回；
//从鼠标光标获取方向，设置合理的操纵速度
角度y=（浮动）（（中间x-mpx））/1000；//1000
角度z=（浮动）（（中间y-mpy））/1000；//1000
//该值越高，摄影机环视四周的速度越快。
objCamera.mView.y+=角度_z*2；
//限制绕x轴旋转
如果（（objCamera.mView.y-objCamera.mPos.y）>8）objCamera.mView.y=objCamera.mPos.y+8；
如果（（objCamera.mView.y-objCamera.mPos.y）我不完全确定您在上面做什么

就我个人而言，我只允许使用一个简单的4x4矩阵。任何实现都可以。要旋转你，只需使用鼠标x和y的变化作为euler输入，围绕y和x轴旋转。互联网上有很多代码可以为你做到这一点

某些矩阵库不会为您提供“MoveForward（）”函数。如果是这种情况，则可以很容易地向前移动。第三列（如果使用行主矩阵，则为行）是向前向量。将其提取。将其归一化（无论如何都应将其归一化，因此可能不需要此步骤）.将其乘以您希望向前移动的数量，然后将其添加到位置（第4列/行）

现在是奇数部分。视图矩阵是一种特殊类型的矩阵。上面的矩阵定义了视图空间。如果将当前模型矩阵乘以该矩阵，则不会得到预期的答案。因为您希望对其进行变换，使相机位于原点。因此，您需要有效地撤消相机变换n将对象重新定向到上面定义的视图。为此，将模型矩阵乘以视图矩阵的倒数

现在，在正确的视图空间中定义了一个对象

这是我非常简单的camera类。它不处理您描述的功能，但希望能给您一些关于如何设置该类的想法（请注意，我使用的是row major，即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;
}

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

我不完全确定你在上面做什么

就我个人而言，我只允许使用一个简单的4x4矩阵。任何实现都可以。要旋转你，只需使用鼠标x和y的变化作为euler输入，围绕y和x轴旋转。互联网上有很多代码可以为你做到这一点

某些矩阵库不会为您提供“MoveForward（）”函数。如果是这种情况，则可以很容易地向前移动。第三列（如果使用行主矩阵，则为行）是向前向量。将其提取。将其归一化（无论如何都应将其归一化，因此可能不需要此步骤）.将其乘以您希望向前移动的数量，然后将其添加到位置（第4列/行）

现在是奇数部分。视图矩阵是一种特殊类型的矩阵。上面的矩阵定义了视图空间。如果将当前模型矩阵乘以该矩阵，则不会得到预期的答案。因为您希望对其进行变换，使相机位于原点。因此，您需要有效地撤消相机变换n将对象重新定向到上面定义的视图。为此，将模型矩阵乘以视图矩阵的倒数

现在，在正确的视图空间中定义了一个对象

这是我非常简单的camera类。它不处理您描述的功能，但希望能给您一些关于如何设置该类的想法（请注意，我使用的是row major，即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;
}

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

我同意Goz的观点。如果要表示仿射变换，如旋转+平移，则需要使用

假设没有缩放或剪切，则4x4矩阵表示以下内容：

第0行至第2行：本地坐标系的三个基向量（即x、y、z）

第3行：源代码的当前翻译

所以要沿着你的局部x向量移动，就像Goz说的，因为你可以假设它是一个单位向量
如果没有缩放/剪切，只需将其乘以移动步长（+ve或-ve），然后将合成向量添加到矩阵的第4行
举一个简单的例子，从原点开始，将局部帧设置为世界帧，那么你的矩阵看起来像这样

1 0 0我同意Goz。如果要表示仿射变换，如旋转+平移，则需要使用

假设没有缩放或剪切，则4x4矩阵表示以下内容：

第0行至第2行：本地坐标系的三个基向量（即x、y、z）

第3行：源代码的当前翻译

所以要沿着你的局部x向量移动，就像Goz说的，因为你可以假设它是一个单位向量
如果没有缩放/剪切，只需将其乘以移动步长（+ve或-ve），然后将合成向量添加到矩阵的第4行
以starti为例