GLM не правильно отклоняется от кватерниона [закрыто] ⇐ C++

[Anonymous]

В своей игре я использую C++ 17 GLFW, GLEW и glm. У меня есть вращения, хранящиеся с кватернионами. Я поворачиваю вращение игроков на кватернион, а позже конвертирую вращение игрока в vec3, чтобы попасть туда, куда они смотрят. Я пытаюсь заставить игрока двигаться с помощью рыскания, но рыскание неправильное.

Код: Выделить всё

glm::eulerAngles

возвращает другой угол Эйлера, чем мне хотелось бы. Я вращаюсь только по оси Y, но он возвращает другую ось, которая вращается в ту же сторону.

Код: Выделить всё

 //Transform.h
#include 
#include 
#include 

namespace T1WD {
class GameObject;
class Transform {
public:
Transform();
~Transform();

void GenerateTransformationMatrix();

//Position
void SetPosition(glm::vec3 position);
void SetGlobalPosition(glm::vec3 position);
void Translate(glm::vec3 position);
void OnPositionUpdate();

//Rotation
void SetRotation(glm::quat rotation);
void SetGlobalRotation(glm::quat rotation);
void Rotate(glm::quat rotation);
void OnRotationUpdate();

//Scale
void SetScale(glm::vec3 scale);
void SetGlobalScale(glm::vec3 scale);
void Scale(glm::vec3 scale);
void OnScaleUpdate();

/*
If you are to modify these values with a reference be aware you will have to call the transforms On___Update();
*/
glm::vec3& GetPosition() { return position; }
glm::vec3& GetGlobalPosition() { return global_position; }

glm::quat& GetRotation() { return rotation; }
glm::quat& GetGlobalRotation() { return global_rotation; }

glm::vec3& GetScale() { return scale; }
glm::vec3& GetGlobalScale() { return global_scale; }

glm::mat4& GetTransformationMatrix() { return transformation_matrix;  }
GameObject* gameobject = nullptr;
private:
void CalculateGlobalPosition();
void CalculateGlobalRotation();
void CalculateGlobalScale();

void UpdateChildrenTransformations();

glm::vec3 position;
glm::quat rotation;
glm::vec3 scale;

glm::vec3 global_position;
glm::quat global_rotation;
glm::vec3 global_scale;

glm::mat4 transformation_matrix;
};
}

Transform.cpp

Код: Выделить всё

#include "Transform.h"

#include "OGLEngine/Object/GameObject.h"

#include 
#include 
#include "glm/glm.hpp"

using namespace T1WD;
Transform::Transform() {
global_scale = glm::vec3(1.0f, 1.0f, 1.0f);
scale = glm::vec3(1.0f, 1.0f, 1.0f);
rotation = glm::angleAxis(glm::radians(0.0f), glm::vec3(0.0f,
1.0f, 0.0f));
global_rotation = rotation;
}
Transform::~Transform() {

}
void Transform::SetPosition(glm::vec3 position) {
//Relative Position
this->position = position;
CalculateGlobalPosition();
GenerateTransformationMatrix();
UpdateChildrenTransformations();
}
void Transform::SetGlobalPosition(glm::vec3 position) {
glm::vec3 parents_global_pos(0.0);
if (gameobject->parent)
parents_global_pos = gameobject->parent->GetGlobalPosition();

this->position = position - parents_global_pos;
CalculateGlobalPosition();
GenerateTransformationMatrix();
UpdateChildrenTransformations();

}
void Transform::Translate(glm::vec3 position) {
this->position += position;
CalculateGlobalPosition();
GenerateTransformationMatrix();
UpdateChildrenTransformations();
}

void Transform::OnPositionUpdate() {

CalculateGlobalPosition();
GenerateTransformationMatrix();
UpdateChildrenTransformations();
}

void Transform::SetRotation(glm::quat rotation) {
this->rotation = rotation;
CalculateGlobalRotation();
GenerateTransformationMatrix();
UpdateChildrenTransformations();
}
void Transform::SetGlobalRotation(glm::quat rotation) {
glm::quat parent_global_rotation(1.0f, 0.0f, 0.0f, 0.0f);
if (gameobject->parent)
parent_global_rotation = gameobject->parent-

GetGlobalRotation();

Код: Выделить всё

this->rotation = rotation - parent_global_rotation;
CalculateGlobalRotation();
GenerateTransformationMatrix();
UpdateChildrenTransformations();
}
void Transform::Rotate(glm::quat rotation) {
this->rotation = rotation * this->rotation;
CalculateGlobalRotation();
GenerateTransformationMatrix();
UpdateChildrenTransformations();
}
void Transform::OnRotationUpdate() {

CalculateGlobalRotation();
GenerateTransformationMatrix();
UpdateChildrenTransformations();
}

void Transform::SetScale(glm::vec3 scale) {
this->scale = scale;
CalculateGlobalScale();
GenerateTransformationMatrix();
UpdateChildrenTransformations();
}
void Transform::SetGlobalScale(glm::vec3 scale) {
glm::vec3 parents_global_scale(0.0);
if (gameobject->parent)
parents_global_scale = gameobject->parent->GetGlobalScale();

this->scale = scale - parents_global_scale;
CalculateGlobalScale();
GenerateTransformationMatrix();
UpdateChildrenTransformations();
}
void Transform::Scale(glm::vec3 scale) {
this->scale *= scale;
CalculateGlobalScale();
GenerateTransformationMatrix();
UpdateChildrenTransformations();
}

void Transform::OnScaleUpdate() {
CalculateGlobalScale();
GenerateTransformationMatrix();
UpdateChildrenTransformations();

Код: Выделить всё

 void Transform::CalculateGlobalPosition() {
this->global_position = position;
if (gameobject->parent != nullptr)
global_position += gameobject->parent->GetGlobalPosition();
}
void Transform::CalculateGlobalRotation() {
this->global_rotation = rotation;
//if (gameobject->parent != nullptr)
//global_rotation *= gameobject->parent->GetGlobalRotation();
}

void Transform::CalculateGlobalScale() {
this->global_scale = scale;
if (gameobject->parent != nullptr)
global_scale += gameobject->parent->GetGlobalScale();
}

void Transform::UpdateChildrenTransformations() {
for (GameObject* object :  gameobject->children) {
Transform transform = object->transform;
transform.CalculateGlobalPosition();
transform.CalculateGlobalRotation();
transform.CalculateGlobalScale();
transform.GenerateTransformationMatrix();
}
}
void Transform::GenerateTransformationMatrix() {
transformation_matrix = glm::mat4x4(1.0f);
transformation_matrix = glm::translate(transformation_matrix,
global_position);

transformation_matrix *= glm::toMat4(global_rotation);
transformation_matrix = glm::scale(transformation_matrix,
global_scale);
}

Код: Выделить всё

    glm::quat& q = gameobject->GetRotation();
float new_Yaw = (180.0f / 3.14159f) * glm::eulerAngles(q).y;

//Not giving correct values
std::cout 

Подробнее здесь: [url]https://stackoverflow.com/questions/78520427/glm-not-getting-yaw-from-quaternion-correctly[/url]