Euler Angles zu Vorwärts-Vektor konvertieren

Treue Seele

Wohnort: Innsbruck, Tirol

11.01.2016, 17:24

Euler Angles zu Vorwärts-Vektor konvertieren

Hallo Leute,
Ich schreibe gerade das Grungerüst für ein 3D Spiel in C++ und OpenGL.
Die "Engine" basiert auf einem simplen Entity-Component-System, also habe ich eine Klasse namens TransformComponent, welche Position, Rotation und Skalierung speichert und Berechnungen mit ihnen durchführt. Meine Rotation wird nicht in einer Quaternion sondern in Euler Angles (3x float) gespeichert.

Nun zum eigentlichen Problem:
Ich möchte eine Funktion schreiben welche mir, Anhand der Euler Angles, den Vorwärts-Vektor zurückgibt.
In 2 Dimensionen ist das ganze kein Problem: V = vec2(sin(angle), cos(angle)).
Leider komme ich aber nach langem Überlegen nicht darauf, wie ich das ganze in 3 Dimensionen umsetze.
Gibt es dafür eine Formel, oder muss ich mein System auf Quaternions umstellen?

Danke im Voraus,
Krane

Zum Seitenanfang

Legend

Alter Hase

Beiträge: 731

Beruf: Softwareentwickler

11.01.2016, 18:00

Na ja, wenn du den untransformierten Vorwärtsvektor kennst, müsstest du diesen natürlich auch durch deine wahrscheinlich schon bestehende Transformation für Vektoren in das Zielkoordinatensystem jagen können.

Sprich, du hast eine Transformation T von dem lokalen Koordinatensystem des Objekts in den Worldspace. Dann musste der untransformierte Vorwärtsvektor sich in den transformierten Vektor v' durch v' = T * v bringen lassen.

"Wir müssen uns auf unsere Kernkompetenzen konzentrieren!" - "Juhu, wir machen eine Farm auf!"

Netzwerkbibliothek von mir, C#, LGPL: https://sourceforge.net/projects/statetransmitt/

Zum Seitenanfang

Treue Seele

Wohnort: Innsbruck, Tirol

11.01.2016, 18:19

Hmm, meinst du die Model Matrix des Objektes?
Mit glm kann man leider, soweit ich weiß, keine Vektoren mit 4x4Matrizen multiplizieren.

Hier etwas Code um das ganze besser zu veranschaulichen:

C-/C++-Quelltext

#include "Component.h"
#include <glm/glm.hpp>
#include <glm/gtx/transform.hpp>
#include <vector>
#include <iostream>

class TransformComponent : public Component
{
    public:
        TransformComponent();
        virtual ~TransformComponent();

        void Update() {}

        void Translate(glm::vec3 delta);
        void Rotate(glm::vec3 delta);
        void RotateAround(glm::vec3 delta) {};
        void Scale(glm::vec3 delta);

        glm::mat4 GetModel() const
        {
            return glm::translate(m_position) * glm::rotate(m_rotation.z, glm::vec3(0,0,1)) * glm::rotate(m_rotation.y, glm::vec3(0,1,0)) * glm::rotate(m_rotation.x, glm::vec3(1,0,0)) * glm::scale(m_scale);
        }

        glm::vec3 getPosition() { return m_position; }
        glm::vec3 getRotation() { return m_rotation; }
        glm::vec3 getScale() { return m_scale; }

        void setPosition(glm::vec3 position) { m_position = position; }
        void setRotation(glm::vec3 rotation) { m_rotation = rotation; }
        void setScale(glm::vec3 scale) { m_scale = scale; }

        glm::vec3 getForward() { return glm::vec3(0,0,1)*GetModel(); } // <-Problem

        void AddChildTransform(TransformComponent* pChildTransform) { m_childTransforms.push_back(pChildTransform); pChildTransform->setParentTransform(this); }
        void setParentTransform(TransformComponent* pParentTransform) { m_pParentTransform = pParentTransform; }

    private:
        glm::vec3 m_position;
        glm::vec3 m_rotation;
        glm::vec3 m_scale;

        std::vector<TransformComponent*> m_childTransforms;
        TransformComponent* m_pParentTransform;
};

Zum Seitenanfang

Treue Seele

Wohnort: Innsbruck, Tirol

17.01.2016, 12:57

Leider habe ich nach langem Suchen immer noch keine Lösung für mein Problem gefunden.
Ich habe meine Rotation von EulerAngles auf Quaternions geändert, doch auch so erhalte ich komplett falsche Werte.

Hier ist meine getForward Funktion:

C-/C++-Quelltext

        glm::vec3 getForward()
        {
            const float* matrix = glm::value_ptr(m_modelMatrix);

            std::cout << matrix[6] << " - " << matrix[8] << " - " <<  matrix[10] << std::endl;

            return glm::vec3(matrix[6], matrix[8], matrix[10]);
        }

Komischerweise erhöhen sich die Werte von matrix[6] und matrix[8] in jedem Frame, ohne dass irgendwelche Transformationen vorgenommen werden.
Bin gerade echt am verzweifeln. :/

Zum Seitenanfang

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

17.01.2016, 13:04

Wie genau kommst du auf die Indices 6, 8 und 10? Wieso multiplizierst du Vektor mit Matrix anstatt umgekehrt?

Und natürlich die obligatorische Frage: Aus welchem Grund genau müssen es Eulerwinkel sein?

m4studios

Zum Seitenanfang

Treue Seele

Wohnort: Innsbruck, Tirol

17.01.2016, 13:12

Laut dieser Seite geben Element 6, 8 und 10 den Vorwärts Vektor des Objektes wieder.
Hier sind keine Indices im Spiel. m_modelMatrix ist eine glm::mat4 Matrix.

Die EulerWinkel wurden durch Quaternions ersetzt. Es werden nur noch EulerWinkel in der Rotate() Funktion verwendet, diese werden aber sofort in eine Quaternion umgewandelt.

Ich poste nochmal den aktuellen Code:

C-/C++-Quelltext

class TransformComponent : public Component
{
    public:
        TransformComponent();
        virtual ~TransformComponent();

        void Update()
        {
            m_modelMatrix = glm::translate(m_position) * mat4_cast(m_rotation) * glm::scale(m_scale);
        }

        void Translate(glm::vec3 delta);
        void Rotate(glm::vec3 delta);
        void RotateAround(glm::vec3 delta) {};
        void Scale(glm::vec3 delta);

        glm::mat4 GetModel() const
        {
            return m_modelMatrix;
        }

        glm::vec3 getPosition() { return m_position; }
        glm::quat getRotation() { return m_rotation; }
        glm::vec3 getScale() { return m_scale; }

        void setPosition(glm::vec3 position) { m_position = position; }
        void setRotation(glm::vec3 eulerAngles) { m_rotation = glm::quat(eulerAngles); }
        void setScale(glm::vec3 scale) { m_scale = scale; }

        glm::vec3 getForward() <-------
        {
            const float* matrix = glm::value_ptr(m_modelMatrix);

            std::cout << matrix[6] << " - " << matrix[8] << " - " <<  matrix[10] << std::endl;

            return glm::vec3(matrix[6], matrix[8], matrix[10]);
        }

        glm::vec3 getRight()
        {
            return glm::vec3(sin(m_rotation.x+glm::radians(-90.0f)), 0.0f, cos(m_rotation.x+glm::radians(-90.0f)));
        }

        void AddChildTransform(TransformComponent* pChildTransform) { m_childTransforms.push_back(pChildTransform); pChildTransform->setParentTransform(this); }
        void setParentTransform(TransformComponent* pParentTransform) { m_pParentTransform = pParentTransform; }

    private:
        glm::vec3 m_position;
        glm::quat m_rotation;
        glm::vec3 m_scale;

        glm::mat4 m_modelMatrix;

        std::vector<TransformComponent*> m_childTransforms;
        TransformComponent* m_pParentTransform;
};

Zum Seitenanfang

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

17.01.2016, 13:22

Zitat von »Krane«

Laut dieser Seite geben Element 6, 8 und 10 den Vorwärts Vektor des Objektes wieder.

Wo genau willst du das dort gelesen haben? Wenn dann wohl Elemente 8, 9 und 10; aber auch das funktioniert nur wirklich für eine bestimmte Klasse von Transformationsmatrizen und gilt nicht allgemein, im Gegensatz zu dem, was auf dieser Seite so steht...

Zitat von »Krane«

Die EulerWinkel wurden durch Quaternions ersetzt. Es werden nur noch EulerWinkel in der Rotate() Funktion verwendet, diese werden aber sofort in eine Quaternion umgewandelt.

Diese Aussage macht keinen Sinn. Quaternionen sind nur ein Weg um eine bestimmte Klasse von Transformationen (Rotationen) zu repräsentieren. Wenn du aus Eulerwinkeln eine Quaternion baust, verwendest du immer noch Eulerwinkel und wirst eine Quaternion erhalten die beispielsweise völlig äquivalent zu einer aus den selben Eulerwinkeln gebauten Matrix ist...

m4studios

Zum Seitenanfang

Treue Seele

Wohnort: Innsbruck, Tirol

17.01.2016, 13:31

Zitat von »dot«

Wo genau willst du das dort gelesen haben? Wenn dann wohl Elemente 8, 9 und 10; aber auch das funktioniert nur wirklich für eine bestimmte Klasse von Transformationsmatrizen und gilt nicht allgemein, im Gegensatz zu dem, was auf dieser Seite so steht...

Mein Fehler. Meinte natürlich 9,8,10. Leider erhalte ich so aber auch nur den untransformierten Vorwärts Vektor. Also (0,0,1).
Diese Methode scheidet also leider aus.

Hmm, ich orientiere mich in meiner Architektur stark an der Unity Engine. Diese nimmt auch 3 Winkel als Argumente für die Rotate-Funktion, obwohl die Rotation in einer Quaternion gespeichert wird.
Ich denke ich muss mich etwas mehr über Quaternions, vor allem wie man sie einsetzt, informieren.