Как сделать вращение камеры с кватернионами на OpenGL ⇐ C++

[Anonymous]

Я не могу понять, почему у меня возникают проблемы во время раз за разом, после того, как я понял, что my haw находится в диапазоне от -90 до 90 градусов , что вызывает шаг и бросок, чтобы резко измениться, когда достигает границ этих значений. P> У меня есть класс камеры: < /p>
camera.h:
#pragma once

#include "Transform.h"

class Camera {
public:
enum class ECameraProjection
{
Perspective,
Ortho
};

public:
Camera();

void changeCameraProjection(ECameraProjection newProjection);

void setFieldOfView(double fov);
void setAspectRatio(double aspect);
void setClippingPlanes(double nearClip, double farClip);

void setZoom(float zoom);

void setCanMove(bool isMove);

Transform& setTransform();
void setTransform(Transform transform);

Transform getTransform() const;

glm::mat4 getProjectionMatrix() const;
glm::mat4 getViewMatrix() const;
glm::mat4 getPVM() const;

void update();

void updateCameraOrientation(float deltaX, float deltaY, float deltaTime);
void updateCameraPosition(const glm::vec3& direction, float deltaTime);

~Camera();

private:

void updateProjectionMatrix();
void updateViewMatrix();

private:
ECameraProjection m_projectionType;

Transform m_transform;

glm::mat4 m_projection;
glm::mat4 m_view;
glm::mat4 m_model = glm::mat4(1.0f);
glm::mat4 m_PVM;

double m_fieldOfView;
double m_aspect;
double m_farClip;
double m_nearClip;

glm::vec3 cameraUp;

glm::vec3 m_cameraLookAt;
glm::vec3 m_cameraDirection;

float m_zoom;

bool m_canMove;
float m_rotationSpeed;
float m_movementSpeed;
float m_sensitivity;
};
< /code>
camera.cpp:
#include "Camera.h"
#include

Camera::Camera() {
cameraUp = glm::vec3(0.0, 1.0, 0.0);
m_fieldOfView = 45.0;
m_aspect = 16.0 / 9.0;
m_nearClip = 0.1;
m_farClip = 100.0;
m_zoom = 1.0;
m_projectionType = ECameraProjection::Perspective;
m_transform.setTranslation(glm::vec3{ 5.0, 0.0, 5.0 });
m_cameraLookAt = glm::vec3(0.0, 0.0, 0.0);
m_cameraDirection = glm::normalize(m_cameraLookAt - m_transform.getTranslation());
m_canMove = true;
m_sensitivity = 0.03;
m_rotationSpeed = m_movementSpeed = 1.0;
updateProjectionMatrix();
updateViewMatrix();
}

void Camera::changeCameraProjection(ECameraProjection newProjection)
{
if (m_projectionType != newProjection) {
m_projectionType = newProjection;
updateProjectionMatrix();
}
}

void Camera::setFieldOfView(double fov)
{
if (m_fieldOfView != fov) {
m_fieldOfView = fov;
updateProjectionMatrix();
}
}

void Camera::setAspectRatio(double aspect)
{
if (m_aspect != aspect) {
m_aspect = aspect;
updateProjectionMatrix();
}
}

void Camera::setClippingPlanes(double nearClip, double farClip)
{
if (m_nearClip != nearClip || m_farClip != farClip) {
m_nearClip = nearClip;
m_farClip = farClip;
updateProjectionMatrix();
}
}

void Camera::setZoom(float zoom)
{
if (m_zoom != zoom) {
m_zoom = zoom;
updateProjectionMatrix();
}
}

void Camera::setCanMove(bool isMove)
{
if (m_canMove != isMove) {
m_canMove = isMove;
}
}

Transform& Camera::setTransform()
{
return m_transform;
}

void Camera::setTransform(Transform transform)
{
if (m_transform != transform) {
m_transform = transform;
updateViewMatrix();
}
}

Transform Camera::getTransform() const
{
return m_transform;
}

glm::mat4 Camera::getProjectionMatrix() const
{
return m_projection;
}

glm::mat4 Camera::getViewMatrix() const
{
return m_view;
}

glm::mat4 Camera::getPVM() const
{
return m_PVM;
}

void Camera::update()
{
updateViewMatrix();
}

Camera::~Camera() {
}

void Camera::updateCameraOrientation(float deltaX, float deltaY, float deltaTime)
{
if (!m_canMove) return;

bool isLimit = false;

float pitchAngle = (deltaY * m_sensitivity * m_rotationSpeed);
float yawAngle = (deltaX * m_sensitivity * m_rotationSpeed);

glm::vec3 right = m_transform.getRotation() * glm::vec3(1.0f, 0.0f, 0.0f);
glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f);

glm::quat pitchQuat = glm::angleAxis(glm::radians(-pitchAngle), right);
glm::quat yawQuat = glm::angleAxis(glm::radians(-yawAngle), up);

glm::quat targetRotation = yawQuat * pitchQuat;

glm::quat target = glm::cross(targetRotation, m_transform.getRotation());

m_transform.setRotation(target);

glm::vec3 angles = glm::eulerAngles(m_transform.getRotation());
std::cout

Подробнее здесь: https://stackoverflow.com/questions/793 ... -on-opengl