Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Do Jul 10, 2025 18:18

Foren-Übersicht » Programmierung » Einsteiger-Fragen
Unbeantwortete Themen | Aktive Themen



Ein neues Thema erstellen Auf das Thema antworten  [ 22 Beiträge ]  Gehe zu Seite 1, 2  Nächste
Autor Nachricht
 Betreff des Beitrags: 3x glRotate --> Weltkoordinaten?
BeitragVerfasst: Di Mai 12, 2009 19:44 
Offline
DGL Member

Registriert: Di Mai 12, 2009 14:32
Beiträge: 24
Hallo erstmal,

also vielleicht stell ich mich zu dämlich an, aber ich beiß mir die Zähne daran aus. Mit dem Zeichnen usw. habe ich keine Probleme, nur mit dem Umrechnen.

Ich versuche ein Sonnensystem darzustellen. Dazu drehe ich zunächst einmal um die X- und einmal um die Y-Achse, um die Ebene der Kreisbahn des Planeten zu kippen. Dann rotiere ich noch um die Z-Achse, um die Planeten "zu verteilen". Danach verschiebe ich mit glTranslate den Planet auf seine Entfernung X zur Sonne.

Code:
  1. pushmatrix;
  2. glrotatef(QWinkelY,0,1,0);
  3. glrotatef(QWinkelX,1,0,0);
  4. glrotatef(Winkel+(WinkelV*zeitfaktor),0,0,1);
  5. gltranslatef(X,0,0);
  6. gl_kugel2(Planeten[i],[sites]); //Planet als Kugel darstellen
  7. popmatrix;
  8.  


Jetzt weiß ich ja aber nicht die absoluten Koordinaten zum Ursprung (Sonne; 0,0,0). Wie kann ich jetzt die Koordinaten des Planeten ausrechnen? Die Rotation berechne ich folgendermaßen:

Code:
  1. //Z.B. Rotation um X-Achse
  2. //oy,oz sind die ursprünglichen Koordinaten
  3. //x := x;
  4. y := oy * cos(alpha)-oz*sin(alpha);
  5. z := oy * sin(alpha)+oz*cos(alpha);
  6.  


Aber es passt irgendwie nicht. Ich vermute es liegt daran, dass ich bei der OpenGL-Transformation erst danach den Ursprung verschiebe? Danke schonmal im Voraus!

EDIT: Die Reihenfolge der Drehungen habe ich beachtet.


Grüße

Christian


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 13, 2009 03:06 
Offline
DGL Member

Registriert: Mi Mai 06, 2009 15:57
Beiträge: 13
Du brauchst doch garnicht die Koordinaten der Planeten mit Sinus und Cosinus berechnen. Dafür ist ja eben Translate und Rotate der einfachste Weg.

glPushMatrix();
Du fängst am besten mit der Sonne an.
Die Zeichnest du im Ursprung deines Koordinatensystems (0,0,0) mit z.b. glutSolidSphere(3,30,30).
Danach führst du dein glRotatef(winkelPlanet1,0,1,0) aus (Drehung um y-Achse).
Jetzt ein glTranslatef(0,0,10);

Nehmen wir an, du hast anfangs ein rotate um 90 Grad gemacht. Dann den Translate (z-Achse um +10). Dann befindest du dich an der Stelle (wenn man die Weltkoordinaten vor dem rotate+translate nehmen würde) 10,0,0. Durch die Drehung um 90 Grad (CCW) zeigt nämlich die z-Achse in die Richtung, in die Ursprünglich die x-Achse gezeigt hat.
Nach dem Rotate und Translate ist der Ursprung deiner Koordinatensystems also jetzt da, wo der erste Planet hin soll.
Jetzt zeichnest du da deinen Planeten
glPopMatrix();

Der Ursprung des Koordinatensystems ist jetzt wieder im Zentrum der Sonne. Anfangsbedingungen.
Und jetzt gehts weiter mit Planet 2, 3 etc.
glPushMatrix();
Rotation mit winkelPlanet2
Translate entfernugPlanet2
Planet2 zeichnen
PopMatrix(),
...

Zu guter Letzt erhöhst du noch die ganzen Winkel um die gewünschten Werte für den nächsten display-Durchlauf.
P.S.: Achja - Ebene der Kreisbahn der einzelnen Planeten kommt natürlich noch dazu.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 13, 2009 08:46 
Offline
DGL Member

Registriert: Di Mai 12, 2009 14:32
Beiträge: 24
Das ist ja auch nicht das Problem! Das habe ich soweit ja, aber ich möchte später die Weltkoordinaten der Planeten umrechnen in Bildschirmkoordinaten, darum brauche ich die Weltkoordinaten. Außerdem wird es dadurch erleichtert abstände zwischen den Planeten zu berechnen. Die Positionierung der Planeten stellt kein Problem da, nur das Ausrechnen der Position danach. Entweder hab ich dich jetzt falsch verstanden oder du hast mich falsch verstanden.

Danke für deine Antwort und dein Interesse.

btw: Ich hab ein Problem mit gluNewQuadric, da bringt er mir immer eine Zugriffsverletzung.

Code:
  1.  
  2. planeten[i].quadric := gluNewQuadric;
  3. gluQuadricDrawStyle(planeten[i].quadric,GL_LINE);
  4.  


planeten ist ein array of record mit quadric : PGLUquadric.


Grüße

Christian[/code]


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 13, 2009 10:50 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Jan 04, 2008 21:29
Beiträge: 419
Wohnort: Lübeck
wenn du die position am ende brauchst, dann solltest du dir quaternion-rotation anschauen. Das ist ein 4dimensionaler zahlenraum, der dir die möglichkeit gibt zwei 3dimensionale vektoren miteinander zu multiplizieren. Das Ergebnis ist dann eine Rotation des einen Vektors um den Anderen. Also als würdest du etwas um eine beliebige Achse drehen. Da du ja schiefe Rotationsbahnen hast kannst du dann die Achse dieser Bahn mit der Position des Planeten multiplizieren und erhälst die neuen Koordinaten. Diese Koordinaten kannst du auch zum zeichnen benutzen, ohne dass du gltranslatef, oder glrotatef brauchst.
Die Rotation um eine Achse kannst du übrigens auch mit glrotatef(); machen, denn die 3 letzten parameter geben die x,y,z argumente der Drehachse an, allerdings kannst du dann nicht mehr die neuen Koordinaten auslesen. Ich wühl mal bei mir im SourceCode rum, evtl finde ich da was zu!

Edit: hier findest du ne gute erklärung zu dem thema -> http://wiki.delphigl.com/index.php/Quaternion

zunächst braucht man einen 3 und 4dimensionalen vektor :
Code:
  1.  
  2. vec3 = record
  3.   x,y,z:single;
  4. end;
  5.  
  6. vec4 = record
  7.   x,y,z,w:single;
  8. end;
  9.  


und eine funktion, die 4 single in ein quaternion schreibt:
Code:
  1.  
  2. function to_vec4(x,y,z,w:single):vec4;
  3. begin
  4.   Result.x := x;
  5.   Result.y := y;
  6.   Result.z := z;
  7.   Result.w := w;
  8. end;
  9.  


dann brauchst du eine funktion, die dir die conjugation eines quaternion zurück gibt:
Code:
  1.  
  2. function quatcon(v:vec4):vec4;
  3. begin
  4.   Result.x := v.x*-1;
  5.   Result.y := v.y*-1;
  6.   Result.z := v.z*-1;
  7.   Result.w := v.w;
  8. end;
  9.  


Dazu brauchst du eine funktion zur multiplikation von quaternions:
Code:
  1.  
  2. function quatmul(v,w:vec4):vec4;
  3. begin
  4.   Result.x := v.w * w.x + v.x * w.w + v.y * w.z - v.z * w.y;
  5.   Result.y := v.w * w.y + v.y * w.w + v.z * w.x - v.x * w.z;
  6.   Result.z := v.w * w.z + v.z * w.w + v.x * w.y - v.y * w.x;
  7.   Result.w := v.w * w.w - v.x * w.x - v.y * w.y - v.z * w.z;
  8. end;
  9.  


und zu guter letzt eine funktion die für dich die quaternion rotation übernimmt:
Code:
  1.  
  2. function quatrot(angle:single;axis,point:vec3):vec3;
  3. var q,v,s:vec4;
  4.     t:vec3;
  5. begin
  6.   v := to_vec4(point.x,point.y,point.z,0);
  7.   // v ist der zu rotierende vektor, in deinem Fall die Koordinaten deines Planeten
  8.  
  9.   t := smul3(sin(degtorad(angle)/2),norm3(axis));
  10.   // t ist ein temporäre vektor, der den sinus anteil des rotations-quaternions errechnet
  11.   // smul3 multipliziert einen skalar, in diesem Fall den sinus des halben rotations winkels im bogenmaß,
  12.   // mit einem Vektor, der hier die Achse der rotation darstellt
  13.  
  14.   q := to_vec4(t.x,t.y,t.z,cos(degtorad(angle)/2));
  15.   // q ist das endgültige rotationsquaternion, das in den ersten 3 stellen die Achse aus t beinhaltet
  16.   // und in der letzten Stelle den cosinus des halben winkels in Bogenmaß
  17.  
  18.   s := quatmul(quatmul(q,v),quatcon(q));
  19.   // s ist ein quaternion, in dem die fertige rotation gespeichert wird, dazu multipliziert man das
  20.   // rotations quaternion mit dem vector in v und das wieder rum mit der conjugation des rotationsquaternion
  21.  
  22.   Result.x := s.x;
  23.   Result.y := s.y;
  24.   Result.z := s.z;
  25.   // als letztes gibt man die koordinaten des vektors nach der rotation wieder zurück
  26. end;
  27.  


smul3, skalarmultiplikation im 3d-raum:
Code:
  1.  
  2. function smul3(s:single;v:vec3):vec3;
  3. begin
  4.   Result.x := s * v.x;
  5.   Result.y := s * v.y;
  6.   Result.z := s * v.z;
  7. end;
  8.  


norm3, normieren eines 3d-vektors:
Code:
  1.  
  2. function norm3(v:vec3):vec3;
  3. var len:single;
  4. begin
  5.   len := len3(v);
  6.  
  7.   Result.x := v.x / len;
  8.   Result.y := v.y / len;
  9.   Result.z := v.z / len;
  10. end;
  11.  


len3, der betrag eines 3d-vektors:
Code:
  1.  
  2. function len3(v:vec3):single;
  3. begin
  4.   Result := sqrt(sqr(v.x) + sqr(v.y) + sqr(v.z));
  5. end;
  6.  

_________________
Klar Soweit?


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 13, 2009 11:36 
Offline
DGL Member

Registriert: Di Mai 12, 2009 14:32
Beiträge: 24
Zitat:
// v ist der zu rotierende vektor, in deinem Fall die Koordinaten deines Planeten


Aber ich habe doch die Koordinaten des Planeten garnicht. Ich erzeuge einen Planeten, indem ich zufällig drei Winkel generiere und sie dann um die jeweiligen Achsen drehe (glRotate), d.h. für Rotation um die X- und Y-Achse gilt alpha={-5..5}, beta={-5..5} und für die Z-Achse gamma={0..359}. Anschließen wird zufällig noch eine Entfernung zum Stern bestimmt und mit glTranslate entlang der X-Achse dorthin verschoben.

Meinst du mit obigem Zitat, die Koordinaten in Form von (X,0,0) -> Entfernung zum Stern??


Gruß

Christian


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 13, 2009 11:53 
Offline
DGL Member

Registriert: Di Mai 12, 2009 14:32
Beiträge: 24
Ich häng mal das Projekt an. 256 KB Anhang is aber doch bissl klein, oder? Habs halt in drei Teile gepackt.

Steuerung:

Mausdrag -> Drehen
O -> Orbits sichtbar/unsichtbar
G -> Grid sichtbar/unsichtbar
A -> Achsen des Ursprungs

Bisher wird nur auf 1280x1024 optimal dargestellt.


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


Zuletzt geändert von Legnad am Mi Mai 13, 2009 12:00, insgesamt 2-mal geändert.

Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 13, 2009 11:55 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Jan 04, 2008 21:29
Beiträge: 419
Wohnort: Lübeck
also beta und alpha reichen bei dir von -5 bis 5. heißt das, dass du tatsächlich nur eine schwache Neigung der Umlaufbahn zulässt, oder unterteilst du 360° in 11 gleichgroße Stücke? Desweitern interessiert mich, warum du die Lage der Umlaufbahn in Grad hast, sind das die astronogolnomischen (irgendwas mit astro halt^^) Werte für unser Planetensystem, dass du simulieren möchtest, oder ist das Planetensystem fiktiv?

du kannst auch zunächst eine Achse nehmen, am besten die Y-Achse (0,1,0) und diese um dein alpha und beta auf der X&Z-Achse rotieren lassen. Anschließend drehst du dann deine Entfernung in der form (x,0,0) um deine rotierte Y-Achse. Wenn du das mit den Quaternions machst, hast du am ende deine Werte als kartesische Koordinaten in einem Vektor liegen.

zum thema zitat, welches zitat meinst du?

Edit: Ich merke gerade, dass du die Entfernung dann neu berechnen musst. Und zwar, musst du die rotationen die du mit der Y-Achse gemacht hast auch mit dem (x,0,0) vektor machen und dann den rotierten (x,0,0) vektor umd die rotierte Y-Achse drehen.

_________________
Klar Soweit?


Zuletzt geändert von Sellmann am Mi Mai 13, 2009 11:58, insgesamt 1-mal geändert.

Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 13, 2009 11:57 
Offline
DGL Member

Registriert: Di Mai 12, 2009 14:32
Beiträge: 24
Mein Zitat im Vorletzen Beitrag :-D

Nein, das Sonnensystem ist fiktiv. Schau dir am besten mein Anhang im letzten Beitrag an.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 13, 2009 12:14 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Jan 04, 2008 21:29
Beiträge: 419
Wohnort: Lübeck
okay, ich hab mir dein system angeschaut. Ganz durchgestiegen bin ich da nicht, aber was hälst du von der Idee, den umgekehrten weg zu gehen!? Lege doch für deinen Planeten eine rotations Achse als 3d vektor fest und anschließend einen radius für seine entfernung von der Sonne. wenn du das kreuzprodukt aus der Rotationsachse mit Z-Achse normierst und mit dem radius des Planeten multiplizierst erhälst du seine start position, diese brauchst du dann mittels quatrot nur noch um seine Achse mit gewünschtem Winkel rotieren lassen. So sind die planeten an ihrer position UND du kennst die Position, ohne das du 10 milliarden mal sinus/cosinus aufrufen musst. Das ist freundlicher für die CPU und bringt dir was du brauchst.

Klar ist es schade, wenn man sein Projekt komplett umstellen muss, aber "soviel" war es ja noch nicht, wenn das alles war was du mir geschickt hast. Mach dir am besten eine kopie von deinem aktuellen Projekt und änder das zweite ab, dann hast du ein gutes Vergleichs mittel.

aus der Position des Planeten lassen sich die Winkel der umlaufbahn übrigens recht simpel errechnen.. dazu schau mal bei wikipedia nach polar-koordinaten.

_________________
Klar Soweit?


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 13, 2009 12:30 
Offline
DGL Member

Registriert: Di Mai 12, 2009 14:32
Beiträge: 24
wie bestimmt ich am besten den rotationsvektor? einfach zufällig die x- und y-koordinate bestimmen? muss ich dann halt vorher ausrechnen welcher bereich, aber diesmal mit sinus und kosinus, damit kann ich wenigstens richtig was anfangen...hatte nur mathe grundkurs -.-

Ich muss ja dann prinzipiell nicht mehr besonders die Matrix manipulieren, höchstens noch gltranslate.
Supi, ich werds gleich ma probieren!

btw: ja ich weiß :-D der sourcecode meines projekts gehört mal aufgeräumt. ich hatte vor längerer zeit mal experimentell daran gearbeitet, jetzt habe ich mich entschlossen weiter daran zu arbeiten.


Gruß

Christian


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 13, 2009 13:19 
Offline
Forenkatze
Benutzeravatar

Registriert: Mi Okt 22, 2003 18:30
Beiträge: 1945
Wohnort: Närnberch
Programmiersprache: Scala, Java, C*
Quaternion? Erm - das hier ist das Einsteigerforum *g*

Legnad, wenn du die Sachen nur brauchst, um die Bildschirmkoordinaten zu erhalten, dann gibt's dafür einen viel viel einfacherern Weg. Der nennt sich: gluProject :)

_________________
"Für kein Tier wird so viel gearbeitet wie für die Katz'."


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 13, 2009 13:21 
Offline
DGL Member

Registriert: Di Mai 12, 2009 14:32
Beiträge: 24
@Frase:

schon klar, die methode kenn ich, aber dafür brauche ich ja die Weltkoordinaten...


Gruß

Christian


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 13, 2009 13:30 
Offline
Forenkatze
Benutzeravatar

Registriert: Mi Okt 22, 2003 18:30
Beiträge: 1945
Wohnort: Närnberch
Programmiersprache: Scala, Java, C*
öhm und wenn du zum Zeitpunkt, wo du deinen Planeten renderst (Der vorher mit glTranslate und glRotate) dorthin buchsiert wurde, die Abfrage mit gluProject machst? Dann stimmt doch die Matrix und du brauchst die Weltkoordinate auch nicht.

_________________
"Für kein Tier wird so viel gearbeitet wie für die Katz'."


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 13, 2009 13:41 
Offline
DGL Member

Registriert: Di Mai 12, 2009 14:32
Beiträge: 24
hmm, das stimmt, aber da ich auch die entfernungen der planeten voneinander berechnen will, brauch ich sie letztendlich doch :-D

_________________
--
Christian


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 13, 2009 13:59 
Offline
DGL Member

Registriert: Di Mai 12, 2009 14:32
Beiträge: 24
oder kann ich dann mit glunproject die bildschirmkoordinaten wieder zurückrechnen? ist zwar umständlich, aber könnte sogar gehen, oder?

_________________
--
Christian


Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 22 Beiträge ]  Gehe zu Seite 1, 2  Nächste
Foren-Übersicht » Programmierung » Einsteiger-Fragen


Wer ist online?

Mitglieder in diesem Forum: Bing [Bot] und 21 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.

Suche nach:
Gehe zu:  
cron
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.013s | 17 Queries | GZIP : On ]