Wie dreht man einen Vektor von einem gegebenen Richtung

Einer Drehung ist in der Regel definiert über irgendeine Art von Verschiebung (Achse-Winkel, quaternion, euler-Winkel, etc.) aus einer Ausgangsposition. Was du suchst wäre genauer beschrieben werden (meiner Meinung nach) als eine re-Orientierung. Zum Glück ist dies nicht allzu schwer zu tun. Was Sie brauchen, ist eine änderung-der-basis-matrix.

Ersten, können Sie nur definieren, was wir im code arbeiten:

using glm::vec3;
using glm::mat3;

vec3 direction;  //points in the direction of the new Y axis
vec3 vec;        //This is a randomly generated point that we will
                 //eventually transform using our base-change matrix

Zur Berechnung der matrix, müssen Sie erstellen unit-Vektoren für die neuen Achsen. Aus dem obigen Beispiel wird deutlich, dass Sie wollen, dass der Vektor bereitgestellt, um die neue Y-Achse:

vec3 new_y = glm::normalize(direction);

Nun, die Berechnung der X-und Z-Achse werden ein bisschen komplizierter. Wir wissen, dass Sie orthogonal zu einander und zu der Y-Achse, die oben berechnet. Die logischste Art und Weise zu konstruieren, die Z-Achse ist zu vermuten, dass die rotation in der Ebene definiert, die von der alten Y-Achse, die neue Y-Achse. Durch die Verwendung der cross-Produkt können wir berechnen diese Ebene normalen Vektor und verwenden, die für die Z-Achse:

vec3 new_z = glm::normalize(glm::cross(new_y, vec3(0, 1, 0)));

Technisch ist die Normalisierung nicht notwendig ist, da hier sowohl input-Vektoren bereits normiert, aber aus Gründen der übersichtlichkeit habe ich es gelassen. Beachten Sie auch, dass es ein Sonderfall ist, wenn der input Vektor ist colinear mit der Y-Achse, in dem Fall das Kreuzprodukt oben nicht definiert ist. Die einfachste Möglichkeit dieses Problem zu beheben ist zu behandeln, als einen besonderen Fall. Anstelle von dem, was wir bisher haben, wir würden verwenden:

if (direction.x == 0 && direction.z == 0)
{
    if (direction.y < 0) //rotate 180 degrees
       vec = vec3(-vec.x, -vec.y, vec.z);

    //else if direction.y >= 0, leave `vec` as it is.
}
else
{
    vec3 new_y = glm::normalize(direction);

    vec3 new_z = glm::normalize(glm::cross(new_y, vec3(0, 1, 0)));

    //code below will go here.
}

Für die X-Achse, können wir über unsere neue Y-Achse mit dem neuen Z-Achse. Dies ergibt einen Vektor, der senkrecht zu den beiden anderen Achsen:

vec3 new_x = glm::normalize(glm::cross(new_y, new_z));

Wieder, die Normalisierung ist in diesem Fall nicht wirklich notwendig, aber wenn y oder z waren die nicht schon einheitsvektoren, es wäre.

Schließlich, kombinieren wir die neue Achse-Vektoren in eine basis-Wechsel-matrix:

mat3 transform = mat3(new_x, new_y, new_z);

Multiplizieren eines Punkt-Vektors (vec3 vec) von dies ergibt einen neuen Punkt in der gleichen position, aber bezogen auf die neue basis-Vektoren (Achsen):

vec = transform * vec;

Tun, diesen letzten Schritt für jede Ihrer zufällig generierten Punkte und du bist fertig! Keine Notwendigkeit zu berechnen, die Winkel der rotation oder ähnliches.

Als eine Randnotiz, Ihre Methode der Generierung von Zufallszahlen einheitsvektoren werden voreingenommen gegenüber Richtungen Weg von den Achsen. Dies ist, weil die Wahrscheinlichkeit, eine bestimmte Richtung, die gewählt wird, ist proportional zu dem Abstand zu dem am weitesten Punkt möglich in eine bestimmte Richtung. Für die Achsen, das ist 1.0. Für Richtungen wie zB. (1, 1, 1) ist dieser Abstand sqrt(3). Dies kann behoben werden, indem alle Vektoren liegen außerhalb der Einheit Sphäre:

glm::vec3 vec;
do
{
    float xDir = randomByRange(-1.0f, 1.0f);
    float yDir = randomByRange(0.0f, 1.0f);
    float zDir = randomByRange(-1.0f, 1.0f);

    vec = glm::vec3(xDir, yDir, zDir);
} while (glm::length(vec) > 1.0f);  //you could also use glm::length2 instead, and avoid a costly sqrt().

vec = glm::normalize(vec);

Dies würde sicherstellen, dass alle Richtungen haben die gleiche Wahrscheinlichkeit, an den Kosten, wenn Sie extrem unglücklich, die Punkte abgeholt, liegen außerhalb der Einheit Sphäre über und über wieder, und es dauert eine lange Zeit zu erzeugen, das im inneren. Wenn das ein problem ist, könnte es geändert werden, begrenzen der Iterationen: while (++i < 4 && ...) oder durch die Erhöhung des radius, an dem ein Punkt wird akzeptiert jeder iteration. Wenn es >= sqrt(3) alle möglichen Punkte würde als gültig angesehen werden, so dass die Schleife enden würde. Diese beiden Methoden würden eine leichte Vorspannung, Weg von den Achsen, aber in fast jeder realen situation, es wäre nicht nachweisbar.

Setzen alle obigen code zusammen, kombiniert mit Ihren code ein, erhalten wir:

void generateDome(glm::vec3 direction)
{
    //Calculate change-of-basis matrix
    glm::mat3 transform;

    if (direction.x == 0 && direction.z == 0)
    {
        if (direction.y < 0) //rotate 180 degrees
            transform = glm::mat3(glm::vec3(-1.0f, 0.0f  0.0f),
                                  glm::vec3( 0.0f, -1.0f, 0.0f),
                                  glm::vec3( 0.0f,  0.0f, 1.0f));

        //else if direction.y >= 0, leave transform as the identity matrix.
    }
    else
    {
        vec3 new_y = glm::normalize(direction);
        vec3 new_z = glm::normalize(glm::cross(new_y, vec3(0, 1, 0)));
        vec3 new_x = glm::normalize(glm::cross(new_y, new_z));

        transform = mat3(new_x, new_y, new_z);
    }


    //Use the matrix to transform random direction vectors
    vec3 point;
    for(int i=0;i<1000;++i)
    {
        int k = 4; //maximum number of direction vectors to guess when looking for one inside the unit sphere.
        do
        {
            point.x = randomByRange(-1.0f, 1.0f);
            point.y = randomByRange(0.0f, 1.0f);
            point.z = randomByRange(-1.0f, 1.0f);
        } while (--k > 0 && glm::length2(point) > 1.0f);

        point = glm::normalize(point);

        point = transform * point;
        //...
    }
    //...
}

InformationsquelleAutor bcrist