4. es rotiert nicht

es rotiert nicht

  • T

    Hallo!

    Ich hab mir mit glBitmap(...) ein eigenes Symbol erstellt,
    welches auch gezeichnet wird:

    Zeichenfunktion( parameter...)
{
   ....

   glColor3f(1.0f,1.0f,0.0f);

   glRotatef(grd, 0.0, 0.0, 1.0); // funzt nicht!

   glRasterPos3f(eyex, eyey, eyez);
        glCallList(DLidAc);         //selbsterstelltes Symbol
}

    Vorher und nachher werden noch die typischen openGl-Fkt. aufgerufen.
    Wie kann ich jetzt die einzelnen Symbole um die
    eigene Achse zum rotieren bringen?
    (es werden mehrere an verschiedenen Positionen gezeichnet).
    Bis jetzt rotieren die Objekte nur um einen gemeinsamen Punkt oder werden
    Schlangenförmig versetzt.
    Ich habe schon vieles probiert, den Aufruf von glRotatef(...)in
    Kombination mit glLoadIdentity()an verschiedenen Stellen.
    Hat jemand eine Idee?
    Dank euch für's reinschaun! 😮

    0
  • J

    jedes symbol einzeln rotieren und an seine position bringe....

    0
  • T

    ja und wie?

    0
  • J

    du musst die symbole dann einfach einzeln zeichnen können dann macht man sowas in der art (für alle symbole):

    glLoadIdentity();
glTranslatef(...)//an gwünschte koordinaten
glRotatef(...)//torieren
//und jetzt zeichnen

    [ Dieser Beitrag wurde am 19.04.2003 um 23:19 Uhr von japro editiert. ]

    0
  • N

    In DX rotiert man erst und transformiert das Objekt. Ist es in OpenGL anders rum? Weil du erst glTranslate und danach gRotatef aufrufst?

    0
  • N

    Original erstellt von Netzwerk-Latenz:
    In DX rotiert man erst und transformiert das Objekt. Ist es in OpenGL anders rum? Weil du erst glTranslate und danach gRotatef aufrufst?

    Das kommt ganz drauf an was Du machen möchtest, das ist unter DX auch nicht anders.

    0
  • N

    Ich meine jetzt wenn ich ein Objekt um seine eigene Achse rotieren lassen will. Ich muss doch erst rotieren danach transformieren.

    Will ich das sich das Objekt um den Nullpunkt der Weltachse dreht. Transformiere ich und rotiere danach.

    [ Dieser Beitrag wurde am 20.04.2003 um 01:02 Uhr von Netzwerk-Latenz editiert. ]

    0
  • T

    Was meinst Du mit transformieren? Unter diesem Begriff versteht man ALLE Transformationen, also Rotation, Translation, Skalierung usw.!
    Wenn ein Objekt um seine eigene Achse rotieren soll, dann musst Du immer erst rotieren und dann verschieben! Ist doch auch logisch, oder nicht?

    0
  • N

    Ich meinte Translation (also verschieben)

    Ist doch auch logisch, oder nicht?

    Ich habe nie was anderes behaubtet. Nur das beim OpenGL irritiert micht?

    Schau dir mal an was japro gschrieben hat.

    PS: In DX6 war es so das man erst verschoben hat und danach rotiert (Hilfsfunktionen) um eine Rotation um die eigen Achse zu erhalten. Ab Version 7 war das anders (BUG behoben). Nur am Rande.

    [ Dieser Beitrag wurde am 20.04.2003 um 02:22 Uhr von Netzwerk-Latenz editiert. ]

    0
  • T

    Edit:
    Hmmm,... ich habe gerade mal im DX 6 SDK nachgesehen und Du hast wirklich recht! Aber wieso das da anders funktionierte, habe ich noch nicht ganz verstanden. Dem werde ich auf den Grund gehen 😉
    Die Anordnung der Matrixelemente ist auf jeden Fall genau wie heute, und die Transformatione eines Vektors auch! Wie kann das dann funktionieren?! Ich werde mir mal D3DMath_MatrixMultiply genauer ansehen!

    Edit 2:
    Ich habe den Grund gefunden! Schau hier, das ist aus D3DMATH.CPP entnommen:

    //-----------------------------------------------------------------------------
// Name: D3DMath_MatrixMultiply()
// Desc: Pre-multiplies matrix B onto matrix A, as in: Q = b * a.
//-----------------------------------------------------------------------------
VOID D3DMath_MatrixMultiply( D3DMATRIX& q, D3DMATRIX& a, D3DMATRIX& b )

    Q = b * a
    Seltsamerweise nicht a * b. In Wirklichkeit war es also genau wie heute, nur dass die komischerweise die Parameter vertauscht haben! 🙄

    [ Dieser Beitrag wurde am 20.04.2003 um 12:20 Uhr von TomasRiker editiert. ]

    0
  • J

    ich muss sagen ich war auch immer irritiert weil man die transformationen sozusagen in verkehrter reihenfolge machen musst. (wars von pov ray ganz anders gewohnt) aber das hat wohl irgendwas mit den matrizen zu tun und das hab ich eh noch nicht volständig geblickt (muss man das?)

    mfg japro 😃

    0
  • N

    Ich nehme an das OpenGL das so macht. Es gibt eine Sichtmatrix (nennt man das so? ) mit dieser Matrix rendert er die Objekte. Diese Matrix ändert man mit glTranslate bzw glRotatef.

    bei glTranslate addiert er die neuen x,y,z-Werte in die letzte Reihe der Sichtmatrix

    Sicht_mat._41 = x;
    Sicht_mat._42 = y;
    Sicht_mat._43 = z;

    Die Funktion glRotatef errechnet erst eine Rotationsmatix und multipliziert die Rotationsmatrix mit der Sichtmatrix

    in dieser Reihenfolge

    Sicht_mat=Sicht_mat*Rot_mat

    dieser Reihenfolge hat die Auswirkung das man in OpenGL erst die Funktion glTranslate aufruft und danach glRotate.

    Hätte man die Multiplikation so gewählt

    Sicht_mat=Rot_mat*Sicht_mat

    müsste man erst glRotate danach glTranslate aufrufen.

    Wie gesagt ich weiss nicht wie OpenGL implementiert wurde ist nur eine Theorie.

    0
  • T

    Wie OpenGL's Matrizen funktionieren ist doch total logisch, z.B.:
    M sei die aktuelle Modelview Matrix und die folgenden Befehle werden in dieser Reihenfolge im Programm ausgefueht:

    glLoadIdentity() --> M wird mit der 'Identity' I ersetzt--> M = I

    glTranslate() --> M = M * T = T, da M Identity

    glRotate() --> M = T * R

    glScale() --> M = T * R * S

    glRotate() --> M = T * R * S * R

    ....
    jeder dieser Befehle, ausser glLoad*() Befehle multipliziert die aktuelle Matrix M mit der entsprechenden Transformationsmatrix (gluLookAt() ist auch so ein 'mulitplizier' Befehl)

    Man sollte sich nicht verwirren lassen, das man alles irgendwie umgekehrt schreiben muss. Das hat mit der API nichts zu tun, sondern eher mit dem mathematischen Verstaendnis und Vorstellung wie Matrixtransformationen funktionieren:

    z.B. der letzte Schritt, M = T * R * S * R
    jetzt rueckwaerts lesen:
    - ein Vertex wird rotiert,
    - dann skaliert
    - dann wird wieder rotiert
    - und wird er verschoben.

    Sowas wird dann logisch wenn man sichs vorstellen kann.
    ~tOmUsA
    Als erst

    0
Anmelden zum Antworten