C++ 在opengl中限制绕x轴旋转

为了好玩，我用opengl制作了一个3d相机。它工作得很好，除了我不知道如何限制绕x轴的旋转。如果向上滚动过多，上下控件将反转。我已尝试将

camFront.y

变量限制为任意值，但相机仍会在x轴上翻转

这是我的密码：

#ifndef CAMERA_H
#define CAMERA_H

#include <GL/glew.h>

#include <GLFW/glfw3.h>

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/quaternion.hpp>

#define WORLD_UP glm::vec3(0.0f, 1.0f, 0.0f)

#include <iostream>


enum CamDirection {
    CAM_FORWARD,
    CAM_BACKWARD,
    CAM_LEFT,
    CAM_RIGHT
};


class Camera {
public:
    void cameraUpdate();

    glm::mat4 getViewMatrix();

    Camera();

    Camera(glm::vec3 startPosition);

    void move(CamDirection dir, GLfloat deltaTime);

    void look(double xOffset, double yOffset);

    void update();

private:

    glm::vec3 camPos;
    glm::vec3 camFront;
    glm::vec3 camUp;
    glm::vec3 camRight;

    const GLfloat camSpeed = 5.05f;

};

glm::mat4 Camera::getViewMatrix() {
    return glm::lookAt(camPos, camPos + camFront, camUp);
}

Camera::Camera():
    camPos  (glm::vec3(0.0f, 0.0f,  0.0f)),
    camFront(glm::vec3(0.0f, 0.0f, -1.0f)),
    camUp   (WORLD_UP)
{}

Camera::Camera(glm::vec3 startPos):
    camPos   (startPos),
    camFront (glm::vec3(0.0f, 0.0f, -1.0f)),
    camUp    (WORLD_UP)
{}

void Camera::move(CamDirection dir, GLfloat deltaTime) {
    const GLfloat v = camSpeed * deltaTime;
    if (dir == CAM_FORWARD)
        camPos += v * camFront;
    else if (dir == CAM_BACKWARD)
        camPos -= v * camFront;
    else if (dir == CAM_RIGHT)
        camPos += v * camRight;
    else
        camPos -= v * camRight;
}
void Camera::look(double xOffset, double yOffset) {
    glm::quat startQuat = {0, camFront.x, camFront.y, camFront.z};

    glm::quat rotation = glm::angleAxis((GLfloat)xOffset, glm::vec3(0.0f, 1.0f, 0.0f));
    glm::quat view = startQuat * rotation;

    rotation = glm::angleAxis((GLfloat)yOffset, glm::vec3(-1.0f, 0.0f, 0.0f));
    view = view * rotation;

    camFront = glm::vec3(view.x, view.y, view.z);
    std::cerr << camFront.x << ' ' << camFront.y << ' ' << camFront.z << std::endl;

}

void Camera::update() {
        // Also re-calculate the Right and Up vector
        camRight = glm::normalize(glm::cross(camFront, WORLD_UP));  // Normalize the vectors, because their length gets closer to 0 the more you look up or down which results in slower movement.
        camUp    = glm::normalize(glm::cross(camRight, camFront));
}
#endif // CAMERA_H

\ifndef摄像机
#定义摄像机
#包括
#包括
#包括
#包括
#包括
#包括
#定义全局glm:：vec3（0.0f、1.0f、0.0f）
#包括
枚举方向{
卡莫向前，
卡穆向后，
卡莫左，
卡莫，对
};
类摄像机{
公众：
void cameraUpdate（）；
glm:：mat4 getViewMatrix（）；
摄像机（）；
摄像机（glm:：vec3起始位置）；
无效移动（CamDirection dir，GLfloat deltaTime）；
无效外观（双X偏移，双Y偏移）；
无效更新（）；
私人：
glm：：vec3坎波斯；
glm：：vec3 camFront；
glm:：vec3-camUp；
glm:：vec3 camRight；
常数GLfloat camSpeed=5.05f；
};
glm:：mat4摄像头：：getViewMatrix（）{
返回glm:：lookAt（camPos，camPos+camFront，camUp）；
}
摄影机：：摄影机（）：
坎波斯（glm:：vec3（0.0f，0.0f，0.0f）），
camFront（glm:：vec3（0.0f，0.0f，-1.0f）），
卡姆普（世界杯）
{}
摄像头：：摄像头（glm：：vec3 startPos）：
坎波斯（startPos），
camFront（glm:：vec3（0.0f，0.0f，-1.0f）），
卡姆普（世界杯）
{}
无效摄影机：：移动（摄影机方向dir、GLfloat deltaTime）{
常量GLfloat v=凸轮速度*增量时间；
if（dir==CAM_FORWARD）
camPos+=v*camFront；
else if（dir==CAM\u向后）
camPos-=v*camFront；
else if（dir==CAM_RIGHT）
camPos+=v*camRight；
其他的
坎波斯-=v*camRight；
}
无效摄影机：：外观（双X偏移，双Y偏移）{
glm:：quat startQuat={0，camFront.x，camFront.y，camFront.z}；
glm:：quat rotation=glm:：angleAxis（（GLfloat）xOffset，glm:：vec3（0.0f，1.0f，0.0f））；
glm:：四视图=开始四视图*旋转；
旋转=glm:：角度轴（（GLfloat）Y偏移，glm:：vec3（-1.0f，0.0f，0.0f））；
视图=视图*旋转；
camFront=glm:：vec3（view.x、view.y、view.z）；
std:：cerr在将
视图.y
和
视图.z
值分配给
camFront
之前，需要将其最大值限制为89度，最小值限制为-89度。在90度和-90度时，它开始反转。因此，一个非常简单的方法是

if(view.y > 89)
{
  view.y = 89;
}
if(view.y < -89)
{
  view.y = -89;
}
if(view.z > 89)
{
  view.z = 89;
}
if(view.z < -89)
{
  view.z = -89;
}

if（视图y>89）
{
视图y=89；
}
如果（视图y<-89）
{
视图y=-89；
}
如果（视图z>89）
{
视图z=89；
}
如果（视图z<-89）
{
视图z=-89；
}