DGL • Thema anzeigen - Ausrichtung eines Objekts [ungelöst]

Ausrichtung eines Objekts [ungelöst]

Moderator: DGL-Team

Seite 1 von 1

[ 4 Beiträge ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Loesil

Betreff des Beitrags: Ausrichtung eines Objekts [ungelöst]

Verfasst: Mi Feb 08, 2012 13:11

DGL Member

Registriert: So Feb 05, 2012 02:02
Beiträge: 3
Programmiersprache: c++

Hallo zusammen,

Ausgangslage:
Ich möchte ein Objekt um ein anderes im 3D Raum drehen. Die Drehungen sollen nacheinander ausgeführt werden.
Ich kenne den Ursprung um den ich drehe (immer 0/0/0 da Translation später kommt). Den Ausgangspukt meines Objektes bestimme ich über die Distanz zum Ursprung, also 0/0/distance. Als erstes drehe ich um die Y Achse (also nach rechts/links) um z.B. 60°. Danach erfolgt eine Drehung um die neue X Achse (also nach oben/unten) um z.B. 80°.

Das ganze realisiere ich über Matrixrotation und erhalte danach den neuen Punkt (berechn ung stimmt).

Nun möchte ich das Objekt so ausrichten, dass es zum Ursprung guckt. Dafür rotiere ich das Objekt um den 1. Winkel (in unserem Beispiel 60°). Schon schaue ich zum horizontalen Mittelpunkt.

Das Problem:

Ich möchte auch zum vertikalen Mittelpunkt schauen. Allerdings kann ich dafür nicht den 2. Winkel (in unserem Beispiel 80°) verwenden.
Wie komme ich auf den richtigen Wert, bzw rotiere ich falsch?

Momentant rotiere ich per:
if (this->direction.x != 0)
{
glRotated(this->direction.x, 1, 0, 0);
}
if (this->direction.y != 0)
{
glRotated(this->direction.y, 0, 1, 0);
}
if (this->direction.z != 0)
{
glRotated(this->direction.z, 0, 0, 1);
}

Bitte um hilfe bin zu blöd dazu (trotz dass ich lange in tutorials gesucht habe...)

Wenn ihr mehr Code braucht, z.B. zur Matrixrotation o.a. einfach hinschreiben, dann Poste ich den benötigten code

THX im vorraus an jeden der sich mindesten die zeit genommen hat mal durch den thread zu schauen

Zuletzt geändert von Loesil am Do Feb 09, 2012 19:29, insgesamt 1-mal geändert.

Nach oben

Ida

Betreff des Beitrags: Re: Ausrichtung eines Objekts

Verfasst: Mi Feb 08, 2012 14:20

DGL Member

Registriert: Mi Apr 13, 2011 22:05
Beiträge: 218
Programmiersprache: Lazarus/FPC

Es macht einen Riesenunterschied in welche Richtung du zuerst rotierst!
Um zum Urpsrung "zurückzuschaun" müsstest du erst um die (warscheinlich weniger als 80°) auf der X-Achse drehen, danach die 60° Y-Achse.

Du plazierst ja das Objekt....60°Y(linke/rechts), distanz, 80°X(rauf/runter), neue Distanz....fals ich das jetzt richtig verstanden habe!!!

Und nun willst du das es zum urpsrung zurückschaut, die 80° stimmen da ja sicher nicht mehr, ausser Distanz 1 wäre gleich 0.

Ich hoffe ich habs so richtig verstanden....du könntest dir jetzt mit sinus, cosinus, tangens den neuen Winkel zwischen Urpsrung und Objektposition ausrechnen, was anderes fällt mir da auch grad nicht ein!

_________________
Ich teile manchmal heimlich durch Null. - Alber Einstein

Nach oben

Loesil

Betreff des Beitrags: Re: Ausrichtung eines Objekts

Verfasst: Mi Feb 08, 2012 17:29

DGL Member

Registriert: So Feb 05, 2012 02:02
Beiträge: 3
Programmiersprache: c++

Hier ein wenig Code zum Verständniss:

Hier meine 4x4 Matrix, der Code zum drehen eines Objekts und dann das Drehen des Objekts:

Code:

Loesil::LGE::Matrix::Matrix(Vector _axis, GLdouble _angle)
{
    GLdouble    sine = sin(_angle);
    GLdouble    cosine = cos(_angle);
    GLdouble    oneMinusCosine = 1 - cosine;
 
    _axis.normalize(); 
 
    this->matrix[0][0] = (oneMinusCosine * _axis.x * _axis.x) + cosine;
    this->matrix[0][1] = (oneMinusCosine * _axis.x * _axis.y) - (_axis.z * sine);
    this->matrix[0][2] = (oneMinusCosine * _axis.z * _axis.x) + (_axis.y * sine);
    this->matrix[0][3] = 0.0; 
 
    this->matrix[1][0] = (oneMinusCosine * _axis.x * _axis.y) + (_axis.z * sine);
    this->matrix[1][1] = (oneMinusCosine * _axis.y *_axis.y) + cosine;
    this->matrix[1][2] = (oneMinusCosine * _axis.y * _axis.z) - (_axis.x * sine);
    this->matrix[1][3] = 0.0; 
 
    this->matrix[2][0] = (oneMinusCosine * _axis.z * _axis.x) - (_axis.y * sine);
    this->matrix[2][1] = (oneMinusCosine * _axis.y * _axis.z) + (_axis.x * sine);
    this->matrix[2][2] = (oneMinusCosine * _axis.z * _axis.z) + cosine;
    this->matrix[2][3] = 0.0; 
 
    this->matrix[3][0] = 0.0;
    this->matrix[3][1] = 0.0;
    this->matrix[3][2] = 0.0;
    this->matrix[3][3] = 1.0;
}
 
Vector4 transformVector(Vector4 _vector, Matrix _matrix)
{
    Vector4     ret;
    GLdouble ** transMatrix = _matrix.getMatrix();
    ret.x = _vector.x * transMatrix[0][0] + _vector.y * transMatrix[1][0] + _vector.z * transMatrix[2][0] + _vector.w * transMatrix[3][0];
    ret.y = _vector.x * transMatrix[0][1] + _vector.y * transMatrix[1][1] + _vector.z * transMatrix[2][1] + _vector.w * transMatrix[3][1];
    ret.z = _vector.x * transMatrix[0][2] + _vector.y * transMatrix[1][2] + _vector.z * transMatrix[2][2] + _vector.w * transMatrix[3][2];
    ret.w = _vector.x * transMatrix[0][3] + _vector.y * transMatrix[1][3] + _vector.z * transMatrix[2][3] + _vector.w * transMatrix[3][3];
    
    delete transMatrix;
    return ret;
}
 
Vector4 rotateVector(Vector _vector, Vector _axis, GLdouble _angle)
{
    Matrix matrix = Matrix(_axis, _angle);
 
    return transformVector(Vector4(_vector.x, _vector.y, _vector.z, 0.0), matrix);
}
 
void rotateObject(LGE::PolygonObject * _objects, double _pitch, double _yaw)
{
    LGE::Vector         localX = LGE::Vector(1.0, 0.0, 0.0);
    LGE::Vector         localY = LGE::Vector(0.0, -10.0, 0.0); //-10 ist nru die diztanz zum ursprung um den gedreht werden soll
    LGE::Vector         startX = localY;
 
    localX = LGE::rotateVector(localX, localY, LGE::degree2Radian(_yaw));
    localY = LGE::rotateVector(localY, localX, LGE::degree2Radian(_pitch));
 
    _objects->setDirection(LGE::Point3D(_pitch, _yaw, 0.0)); //_yaw ist hier korrekt, doch _pitch nicht...
    _objects->setPosition(localY); //Position ist korrekt, also scheint die berechnung zu stimmen ;)
}
 
void Loesil::LGE::PolygonObject::drawObject()
{
    glPushMatrix(); 
    glTranslated(this->position.x, this->position.y, this->position.z); 
 
    if (this->direction.y > 0.0) //Rotationen werden nacheinander ausgeführt
    {
        glRotated(this->direction.y, 0.0, 1.0, 0.0);
    }
    if (this->direction.x > 0.0)
    {
        glRotated(this->direction.x, 1.0, 0.0, 0.0);
    }   
    if (this->direction.z > 0.0)
    {
        glRotated(this->direction.z, 0.0, 0.0, 1.0);
    }
 
    glScaled(this->scale.x, this->scale.y, this->scale.z);
    this->polygon->draw();
    
    glPopMatrix();
}

Im Anhang sind Bilder. Die grünen Striche sollten zum Zentrum zeigen.
Bild 1 ist eine draufsicht, bei der ich in der Methode rotateObject bei der Ausrichtung nur Yaw setze und nicht pitch.
In den darauf folgenden Bildern wird der Pitch mit gesetzt und... nun ja... die striche zeigen nicht zum mittelpunkt.
bild2 = von vorne mit pitch, bild3 = von rechts mit pitch, bild 4 mit pitch von oben

(Das Hier als 1. angezeigt Bild ist das 4. was ich aufgenommen habe...)

Du hast keine ausreichende Berechtigung, um die Dateianhänge dieses Beitrags anzusehen.

Nach oben

Flash

Betreff des Beitrags: Re: Ausrichtung eines Objekts [ungelöst]

Verfasst: Mo Feb 13, 2012 00:51

Guitar Hero

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7804
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)

Falls es hilft kann ich auf das Tutorial_Matrix2 verweisen. Eventuell hilft die Visualisierung dem Verständnis.

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Nach oben

Seite 1 von 1

[ 4 Beiträge ]

Foren-Übersicht » Programmierung » Allgemein

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 8 Gäste

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.