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

Aktuelle Zeit: Di Nov 04, 2025 16:58

Foren-Übersicht » Programmierung » OpenGL 		Unbeantwortete Themen | Aktive Themen


Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 2
  [ 26 Beiträge ]  Gehe zu Seite 1, 2  Nächste
  Vorheriges Thema | Nächstes Thema 
Autor Nachricht
Litefora
 Betreff des Beitrags: Kamera um Scene bzw. Objekt drehen.
BeitragVerfasst: Di Apr 02, 2013 08:01 
Offline
DGL Member

Registriert: Do Mär 21, 2013 14:57
Beiträge: 51
Programmiersprache: C#,C++
Morgen Leute,

ich bin noch sehr frisch in der Welt der Grafikprogrammierung und somit auch in OpenGL, übt daher nachsicht bei blöden Fragen. Ich habe bereits sehr viele Forenbeiträge zu diesem Thema gelesen und bereits mit den Funktionen glulookAt und gluPerspective herumgespielt. Wie bereits der Titel verrät möchte ich die Kamera um mein Objekt herum (per Maus) drehen jedoch sehe ich mein gezeichnetes Objekt nicht mehr sobald ich diese Funktionen in meinen Events verwende. Leider komme ich nicht dahinter woran das liegt.

Verwendete Bibliothek: OpenTK, da ich gezwungen bin C# zu verwenden. Ich arbeite mit dem glControl - Fenster um darin zu "zeichnen".

Nun mein Code:

Die folgende Funktion verwende ich um bei der Initialisierung meiner Form und beim resizen die Größe der glControl anzupassen:

Code:
  1. private void SetUpViewPort()
  2.         {
  3.             // Compute the size of the glControl1.
  4.             int width = glControl1.Width;
  5.             int height = glControl1.Height;
  6.  
  7.             // Tell OpenGL how to compute pixels to coordinates.
  8.             GL.Viewport(0, 0, width, height);
  9.  
  10.             // Choose Matrix.
  11.             GL.MatrixMode(MatrixMode.Projection);
  12.  
  13.             // Reset camera.
  14.             GL.LoadIdentity();
  15.  
  16.             // Multiplying the projection matrix with a perspective one.
  17.             OpenTK.Graphics.Glu.Perspective(90.0, width / height, -500, 500);
  18.  
  19.             GL.MatrixMode(MatrixMode.Modelview);
  20.         }


Nach der Initialisierung zeichne ich mein Objekt im Paint-Event wie folgt:

Code:
  1. private void glControl1_Paint(object sender, PaintEventArgs e)
  2.         {
  3.             // Safety test accessing glControl1.
  4.             if (!loaded)
  5.                 return;
  6.            
  7.             // Clear color and depth buffer.
  8.             GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
  9.  
  10.             // Chosing drawing perspective.
  11.             GL.MatrixMode(MatrixMode.Projection);
  12.  
  13.             // Reset drawing perspective.
  14.             GL.LoadIdentity();
  15.  
  16.             // Functions for drawing bodys.
  17.             DrawingAxes();
  18.  
  19.             GL.Color3(Color.ForestGreen);
  20.             Body.drawFrontPlain();
  21.             GL.Color3(Color.Lavender);
  22.             Body.drawTopPlain();
  23.             GL.Color3(Color.Purple);
  24.             Body.drawBotPlain_1();
  25.             GL.Color3(Color.DarkRed);
  26.             Body.drawRarePlain1();
  27.             GL.Color3(Color.DarkBlue);
  28.             Body.drawBotPlain_2();
  29.             GL.Color3(Color.Gold);
  30.             Body.drawRarePlain_2_();
  31.             GL.Color3(Color.LightBlue);
  32.             Body.drawSidePlains();
  33.             Body.drawNurbs();
  34.             // Function for setting spot lights.
  35.             if (lighton == true)
  36.                 AddAmbientLight();
  37.  
  38.             // Display the 3D scene.
  39.             glControl1.SwapBuffers();
  40.         }


Das resizen der Form sieht wie folgt aus:

Code:
  1. private void glControl1_Resize_1(object sender, EventArgs e)
  2.         {
  3.             // Set viewport.
  4.             SetUpViewPort();
  5.  
  6.             // Draw scene new.
  7.             glControl1.Invalidate();
  8.         }


Sobald die Maustaste getätigt wird in der glControl wird dann ein Event ausgelöst in dem ich mit Hilfe der Modelview Matrix über "GL.MatrixMode(MatrixMode.Modelview)" und der Verwendung von glulookAt die Ansicht drehen möchte durch Berechnung von Kugelkoordinaten. Was mache ich verkehrt oder verstehe ich an OpenGL nicht?!

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)
Nach oben
 Profil  
Mit Zitat antworten  
end
BeitragVerfasst: Di Apr 02, 2013 08:50 
Offline
Compliance Officer
Benutzeravatar

Registriert: So Aug 08, 2010 08:37
Beiträge: 460
Programmiersprache: C / C++ / Lua
gluLookAt verwendet man immer dann, wenn man von einer unbekannten (sich ständig ändernden Position) auf ein Objekt schauen möchte - also wenn du dich im Programm bewegst, aber immer auf dein Objekt schauen möchtest.

Zum einfachen Drehen verwendet man das mittlerweile als deprecated gekennzeichnete glRotatef (deprecated, weil man jetzt anscheinend die Matrixen immer selber berechnen soll ^^)

Schau dir doch mal unsere Matrix-Tutorials an, da wird das erklärt ;)

_________________
offizieller DGL Compliance Beauftragter
Never run a changing system! (oder so)
Nach oben
 Profil  
Mit Zitat antworten  
damadmax
BeitragVerfasst: Di Apr 02, 2013 10:49 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java
Du hast da einiges durcheinander gebracht:

1. gluPerspective benötigt für zNear und zFar positive Werte. Siehe hier.

2. Die meiner Meinung nach "normale" Vorgehensweise wäre:

Code:
  1. while (gameRunning) {
  2.  
  3. glMatrixMode(GL_PROJECTION);
  4. glLoadIdentity();
  5. gluPerspective(fov, aspect, zNear, zFar);
  6.  
  7. glMatrixMode(GL_MODELVIEW);
  8. glLoadIdentity();
  9. gluLookAt(1, 0, 0,   0, 0, 0,    0, 1, 0,); // von punkt (1, 0, 0) in richtung mittelpunkt (0,0,0) der szene schauen
  10.  
  11. render(geometry);
  12.  
  13. }


Um dich um das Objekt zu drehen, reicht es, für die eye-koordinaten einfach mittels sin/cos einen vector zusammen zubauen. Die Winkel werden dann von der Mausposition beeinflusst.
z.b:
Code:
  1.  
  2. winkel += maus.deltaX; // veränderung seit letztem durchlauf
  3. eyeVector.set(sin(winkel), 0, cos(winkel));

_________________
Es werde Licht.
glEnable(GL_LIGHTING);
Und es ward Licht.

Zitat aus einem Java Buch: "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off"

on error goto next
Nach oben
 Profil  
Mit Zitat antworten  
nevermind10844
BeitragVerfasst: Mi Apr 03, 2013 00:07 
Offline
DGL Member

Registriert: Di Aug 21, 2012 19:31
Beiträge: 173
Programmiersprache: C#
Moin...
Ich habe mir fuer die steuerung der kamera eine library gebastelt, die auf grundlage von vektorrechnung die neuen werte fuer gluLookat berechnet. Fuer mich ist vektorrechnung deutlich weniger abstrakt als winkelfunktionen und matrizen :D

Grundlegend wird das ganze als kreis betrachtet. Die hoehe wird ignoriert. Die der view vektor (von eye zu lookat) wird berechnet sowie dessen laenge. Dann wird der up vektor zu hilfe genommen und mittels view und up das kreuzprodukt gebildet. Also ein vektor, der im rechten winkel von der ebene wegzeigt. Dieser wird normiert und dann mit einem skalar multipliziert (dieser wert bestimmt wie weit due kamera gedreht wird). Nun wird zwischen dem zielpunkt des neuen vektors und dem lookat ein neuer vektor gebildet. Dieser wird normiert und dann auf die laenge des alten view vektors gebracht. Das ergebnis ist der negative neue view vektor.
(Bin auch in c#+opentk unterwegs)

Ich hoffe das ich nun keinen schund erzaehlt habe. Bin nicht zuhause, sondern vertreibe mir die zeit im billard sport casino :D

Gruesse!

_________________
ack nack nack nack nack
Nach oben
 Profil  
Mit Zitat antworten  
yunharla
BeitragVerfasst: Mi Apr 03, 2013 08:08 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern
end hat geschrieben:
gluLookAt verwendet man immer dann, wenn man von einer unbekannten (sich ständig ändernden Position) auf ein Objekt schauen möchte - also wenn du dich im Programm bewegst, aber immer auf dein Objekt schauen möchtest.

Zum einfachen Drehen verwendet man das mittlerweile als deprecated gekennzeichnete glRotatef (deprecated, weil man jetzt anscheinend die Matrixen immer selber berechnen soll ^^)

Schau dir doch mal unsere Matrix-Tutorials an, da wird das erklärt ;)


Jedes mal wenn wer glu und rotatef nimmt, stirbt ein Panda!

Fuer so eine Kamera sind Spherical Coordinates am leichtesten.
Code:
  1.  
  2. var theta = linksRechts * Math.PI / 180.0; //und den Winkel immer schoen zwischen 0 und 360 Grad lassen :)
  3. var phi = hochRunter *Math.PI / 180.0; //achtung, sollte nicht an 90 oder - 90 grad rankommen
  4. Vector3 forward = new Vector3(
  5.      x: Convert.ToSingle( Math.Cos( theta ) * Math.Cos( phi) ) ,
  6.      y: Convert.ToSingle( Math.Sin( theta ) * Math.Cos( phi ) ) ,
  7.      z: Convert.ToSingle( Math.Sin( phi) )
  8. );
  9.  


anschliessen musst du nur noch deine Modelview Matrix wie folgt befuettern (OpenTK hat ausnahmsweise mal die Funktionen):
Code:
  1.  
  2. GL.MatrixMode( MatrixMode.Modelview );
  3. Matrix4 modelview = Matrix4.LookAt( center + forward * distance ,center , Vector3.UnitZ );
  4.  
  5. GL.LoadMatrix( ref modelview ); //fuer moderne Sachen solltest du hier lieber deinen Uniform setzen
  6.  

_________________
Meine Homepage
Nach oben
 Profil  
Mit Zitat antworten  
Litefora
BeitragVerfasst: Mi Apr 03, 2013 12:42 
Offline
DGL Member

Registriert: Do Mär 21, 2013 14:57
Beiträge: 51
Programmiersprache: C#,C++
Danke für die Antworten. Am besten finde ich die Idee von yunharla.

@yunharla: Was meinst du mit " //und den Winkel immer schoen zwischen 0 und 360 Grad lassen"
bzw. "//achtung, sollte nicht an 90 oder - 90 grad rankommen"


Ich würde mich gern uneingeschränkt um das Objekt drehen können, jedoch klingt das für mich, dass
es Probleme bei Winkeln in der vertikalen < -90° bzsw > 90° zu geben?!



PS: Ich hatte ja erwähnt, dass ich erst in OpenGL einsteige, also bitte Begriffe wie "Uniform" erklären ^^

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)
Nach oben
 Profil  
Mit Zitat antworten  
yunharla
BeitragVerfasst: Mi Apr 03, 2013 15:39 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern
ok mal schritt fuer schritt
Litefora hat geschrieben:
Was meinst du mit " //und den Winkel immer schoen zwischen 0 und 360 Grad lassen"


Ganz einfach wenn dein Winkel kleiner gleich 0 ist addierst du 360. Und wenn er groesser 360 ist ziehst du 360 ab.
Ist nicht unbedingt notwendig, aber sicher ist sicher ;)

Litefora hat geschrieben:
Ich würde mich gern uneingeschränkt um das Objekt drehen können, jedoch klingt das für mich, dass
es Probleme bei Winkeln in der vertikalen < -90° bzsw > 90° zu geben?!

Naja das sollte aussreichen. Ansonsten muesstest du das ganze noch ein wenig umbauen...

Litefora hat geschrieben:
PS: Ich hatte ja erwähnt, dass ich erst in OpenGL einsteige, also bitte Begriffe wie "Uniform" erklären ^^
[/quote][/quote]
Uniforms sind wenn du es so willst externe Variablen fuer Shaderprogramme. Auf die wirst du spaeter noch treffen ;)

_________________
Meine Homepage
Nach oben
 Profil  
Mit Zitat antworten  
Litefora
BeitragVerfasst: Do Apr 04, 2013 07:58 
Offline
DGL Member

Registriert: Do Mär 21, 2013 14:57
Beiträge: 51
Programmiersprache: C#,C++
Also meine Funktion bzw. das MouseMove - Event sieht jetzt bei mir folgendermaßen aus:

Code:
  1.  
  2. private void glControl1_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
  3.         {
  4.             drawing = true;
  5.  
  6.             mouse_previous.X = glControl1.PointToClient(MousePosition).X;
  7.             mouse_previous.Y = glControl1.PointToClient(MousePosition).Y;
  8.         }
  9.  
  10.  
  11. private void glControl1_MouseMove(object sender, System.Windows.Forms.MouseEventArgs e)
  12.         {
  13.             if (drawing == true)
  14.             {
  15.                 // Compute current mouse position.
  16.                 mouse_current.X = glControl1.PointToClient(MousePosition).X;
  17.                 mouse_current.Y = glControl1.PointToClient(MousePosition).Y;
  18.  
  19.                 // Compute moving distance depending on mouse speed.
  20.                 float dx = mouse_current.X - mouse_previous.X;
  21.                 dx *= mouse_speed;
  22.                 float dy = mouse_current.Y - mouse_previous.Y;
  23.                 dy *= mouse_speed;
  24.  
  25.                 // Get angle in rad.
  26.                 var theta = dx * Math.PI / 180.0;
  27.                 var phi = dy * Math.PI / 180.0;
  28.  
  29.                 // Compute position vector.
  30.                 Vector3d forward = new Vector3d(Math.Cos(theta) * Math.Cos(phi),
  31.                                                 Math.Sin(theta) * Math.Cos(phi),
  32.                                                 Math.Sin(phi)
  33.                                                 );
  34.  
  35.                 // Switch do model matrix.
  36.                 GL.MatrixMode(MatrixMode.Modelview);
  37.  
  38.                 // Compute new modelview matrix.
  39.                 Matrix4d modelview = Matrix4d.LookAt(Vector3d.Zero + forward * 1, Vector3d.Zero, Vector3d.UnitY);
  40.  
  41.                 // Set new modelview matrix.
  42.                 GL.LoadMatrix(ref modelview);
  43.  
  44.                 // Update mouse position.
  45.                 mouse_previous.X = mouse_current.X;
  46.                 mouse_previous.Y = mouse_current.Y;
  47.             }
  48.         }
  49.  
  50.  
  51.  
  52. private void glControl1_MouseUp(object sender, System.Windows.Forms.MouseEventArgs e)
  53.         {
  54.             drawing = false;
  55.         }


Problem dabei ist, dass die Kamera immer auf die negative X-Achse gesetzt wird, zwar mit der Blickrichtung auf den Modelview-Ursprung aber danach bewegt sich nichts mehr! Wenn ich dann die Ansicht drehen will "zuckt" zwar das Objekt bzw. das Modelview-Koordinatensystem aber die Ansicht setzt sich danach immer wieder zurück auf die negative X-Achse. Das mit den Winkel zwischen 0 und 360° hab ich jetzt noch weg gelassen.

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)
Nach oben
 Profil  
Mit Zitat antworten  
yunharla
BeitragVerfasst: Do Apr 04, 2013 08:16 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern
Halloechen

Ich sehe da spontant 2 Probleme.

1.) Du uebergibst anscheinend nur die aktuelle Mausbewegung. Du brauchst aber sozusagen den Winkel aller Mausbewegungen zusammen.
Code:
  1.  
  2.   var theta = dx * Math.PI / 180.0;
  3.   var phi = dy * Math.PI / 180.0;
  4.  

sollte etwa so aussehen
Code:
  1.  
  2.   this.theta += dx * Math.PI / 180.0;
  3.   this.phi += dy * Math.PI / 180.0;
  4.  


2.) Als "Oben" gibst du Vector3d.UnitY an. Daher muesstest du im forward Vektor noch y und z vertauschen.

_________________
Meine Homepage
Nach oben
 Profil  
Mit Zitat antworten  
Litefora
BeitragVerfasst: Do Apr 04, 2013 08:21 
Offline
DGL Member

Registriert: Do Mär 21, 2013 14:57
Beiträge: 51
Programmiersprache: C#,C++
Jetzt hab ich es. Jedoch wird viel abgeschnitten. Es ist nicht mehr die komplette Scene bzw. das komplette Objekt zu sehen sobald ich
die Ansicht drehe. Muss ich noch den Blickwinkel irgendwie berechnen?

Und mir ist gerade aufgefallen, dass die positive X-Achse plötzlich mit der negativen ausgetauscht wird. Praktisch wird die komplette
Ansicht an der z-y-Ebene gespiegelt. Sonst funktioniert alles.

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)
Nach oben
 Profil  
Mit Zitat antworten  
Wölfchen
BeitragVerfasst: Do Apr 04, 2013 11:26 
Offline
DGL Member

Registriert: Do Mär 05, 2009 20:17
Beiträge: 284
Wohnort: Kaiserslautern
Litefora hat geschrieben:
Jetzt hab ich es. Jedoch wird viel abgeschnitten. Es ist nicht mehr die komplette Scene bzw. das komplette Objekt zu sehen sobald ich
die Ansicht drehe. Muss ich noch den Blickwinkel irgendwie berechnen?



Könnte eventuell am nearclipping / farclipping liegen..
Nach oben
 Profil  
Mit Zitat antworten  
Litefora
BeitragVerfasst: Do Apr 04, 2013 11:32 
Offline
DGL Member

Registriert: Do Mär 21, 2013 14:57
Beiträge: 51
Programmiersprache: C#,C++
Das hab ich aber extra groß gewählt über meine SetUpViewPort - Funktion die bei der
Initialisierung und dem Resizing aufgerufen wird.

Code:
  1. private void SetUpViewPort()
  2.         {
  3.             // Compute the size of the glControl1.
  4.             int width = glControl1.Width;
  5.             int height = glControl1.Height;
  6.  
  7.             // Tell OpenGL how to compute pixels to coordinates.
  8.             GL.Viewport(0, 0, width, height);
  9.  
  10.             // Choose Matrix.
  11.             GL.MatrixMode(MatrixMode.Projection);
  12.  
  13.             // Reset camera.
  14.             GL.LoadIdentity();
  15.  
  16.             // Multiplying the projection matrix with a perspective one.
  17.             OpenTK.Graphics.Glu.Perspective(90.0, width / height, 500, 500);
  18.         }


Wird das dann in meinem Event nicht mehr berücksichtigt?

Code:
  1.         private void glControl1_MouseMove(object sender, System.Windows.Forms.MouseEventArgs e)
  2.         {
  3.             if (drawing == true)
  4.             {
  5.                 // Compute current mouse position.
  6.                 mouse_current.X = glControl1.PointToClient(MousePosition).X;
  7.                 mouse_current.Y = glControl1.PointToClient(MousePosition).Y;
  8.  
  9.                 // Compute moving distance depending on mouse speed.
  10.                 float dx = mouse_current.X - mouse_previous.X;
  11.                 dx *= mouse_speed;
  12.                 float dy = mouse_current.Y - mouse_previous.Y;
  13.                 dy *= mouse_speed;
  14.  
  15.                 // Get angle in rad.
  16.                 theta += dx * Math.PI / 180.0;
  17.                 phi += dy * Math.PI / 180.0;
  18.  
  19.                 // Set borders from 0 to 360°.
  20.                 if (theta > 2 * Math.PI)
  21.                     theta -= 2 * Math.PI;
  22.                 if (theta < 0)
  23.                     theta += 2 * Math.PI;
  24.  
  25.                 // Angle output.
  26.                 ThetaOutput.Text = "Theta: " + theta;
  27.                 PhiOutput.Text = "Phi: " + phi;
  28.  
  29.                 // Compute position vector.
  30.                 Vector3d forward = new Vector3d(Math.Cos(theta) * Math.Cos(phi),
  31.                                                 Math.Sin(phi),
  32.                                                 Math.Sin(theta) * Math.Cos(phi)
  33.                                                 );
  34.  
  35.                 Vector3d up = new Vector3d();
  36.  
  37.                 // Switch do model matrix.
  38.                 GL.MatrixMode(MatrixMode.Modelview);
  39.  
  40.                 // Compute new modelview matrix.
  41.                 Matrix4d modelview = Matrix4d.LookAt(Vector3d.Zero + forward * 1, Vector3d.Zero, Vector3d.UnitY);
  42.  
  43.                 // Set new modelview matrix.
  44.                 GL.LoadMatrix(ref modelview);
  45.  
  46.                 // Update mouse position.
  47.                 mouse_previous.X = mouse_current.X;
  48.                 mouse_previous.Y = mouse_current.Y;
  49.             }
  50.         }



Oder hängt die von mir zuvor definierte Near- und Farclipping plane (durch Glu.Perspective(..)) vom Up-Vektor ab, was bedeuten würde,
dass ich diesen auf die Kugelkoordinaten anpassen muss, da ich im Moment immer die Y-Achse verwende.

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)
Nach oben
 Profil  
Mit Zitat antworten  
damadmax
BeitragVerfasst: Do Apr 04, 2013 15:49 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java
1. Problem:
Code:
  1. OpenTK.Graphics.Glu.Perspective(90.0, width / height, 500, 500);

Nimm da mal 1.0 als ZNear und 500.0 für ZFar.


2. Problem:
Du bewegst die Kamera auf einem Kreis mit Radius 1. Die Kamera steckt quasi im Objekt.
Code:
  1. Vector3d.Zero + forward * 1

Wenn du anstelle der 1 eine Variable zoom nimmst und z.b. über das Mausrad veränderst....verschwindet zumindest nichts mir hinter der NearClippingPlane :)

_________________
Es werde Licht.
glEnable(GL_LIGHTING);
Und es ward Licht.

Zitat aus einem Java Buch: "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off"

on error goto next
Nach oben
 Profil  
Mit Zitat antworten  
Litefora
BeitragVerfasst: Fr Apr 05, 2013 07:46 
Offline
DGL Member

Registriert: Do Mär 21, 2013 14:57
Beiträge: 51
Programmiersprache: C#,C++
Ja, wenn ich das mache verschwindet das ganze Object hinter einer clipping plane ;D

Was sich jedoch total meiner logik entzieht! Sobald ich mich um mein Objekt auf einer Kugel
mit radius 0,5 bewege und Glu.Perspective unverändert lasse mit 500 für zNear und zFar wird
nichts abgeschnitten.

Klar funktioniert es so, aber ich würde es gern verstehen :shock: :roll: :wink:

Mit Glu.Perspective stelle ich ja meinen Blickwinkel, das Bildverhältnis und die Clipping planes
für Nähe und Ferne ein - relativ zur Position meiner Projectionmatrix, sprich Kamera. Ergo müsste
sich das nach meinem Verständnis auch weiterhin so verhalten, sollte ich die Position der Kamera
bzw. Projectionmatrix verändern!?


Was ich jedoch auch sehr merkwürdig empfinde - sobald ich für den Radius der Kugel, auf der ich
mich bewege eine Variable zoom setze die ich mit dem Mausrad verändere, reduziert oder vergrö-
ßert sich nicht die Entfernung zum Objekt, sondern es scheint als würden sich die Clipping planes
verschieben. Langsam bin ich total verwirrt! :(

Ich würde euch ja gern meinen Soucre-Code geben, aber ich glaube kaum, dass jemand die Zeit
und Lust hat übers Wochenende durch mein rießen Projekt durch zu steigen.

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)
Nach oben
 Profil  
Mit Zitat antworten  
damadmax
BeitragVerfasst: Fr Apr 05, 2013 17:41 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java
Zitat:
... aber ich glaube kaum, dass jemand die Zeit
und Lust hat übers Wochenende durch mein rießen Projekt durch zu steigen.


Ich kapsel alles was mit den Proj. und ModelView Matrizen zu tun hat in eine Klasse Camera.

Mal grob umrissen wie ich vorgehe (obs richtig ist muss jemand anders beurteilen :) ):

Code:
  1. while (_running) {
  2.   // in MatrixMode gl_projection wechseln und mittels gluPerpective setzen
  3.   camera.setProjection();
  4.  
  5.   // in MatrixMode gl_modelview wechseln und aktuelle camera position und rotation anwenden (gluLookAt, oder glTranslate , glRotate, oder glLoadMatrix, egal)
  6.   camera.lookThrough();
  7.  
  8.   scene.render(_renderer);
  9.  
  10. }
  11.  

Die Camera Klasse wird von der Player Klasse oder einer Animations-Klasse gefüttert und eine Instanz wird in der Renderer Klasse umhergetragen.

Code:
  1. void setProjection() {
  2.   GL11.glMatrixMode(GL11.GL_PROJECTION);
  3.   GL11.glLoadIdentity();
  4.   GLU.gluPerspective(75.0f, (float)Display.getWidth() / (float)Display.getHeight(), 0.1f, 1000.0f);
  5. }



Code:
  1. void lookThrough() {
  2.   GL11.glMatrixMode(GL11.GL_MODELVIEW);
  3.   GL11.glLoadIdentity();
  4.   GLU.gluLookAt(eye.x, eye.y, eye.z, center.x, center.y, center.z, 0, 1, 0);
  5. }

_________________
Es werde Licht.
glEnable(GL_LIGHTING);
Und es ward Licht.

Zitat aus einem Java Buch: "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off"

on error goto next
Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 2
  [ 26 Beiträge ]  Gehe zu Seite 1, 2  Nächste
Foren-Übersicht » Programmierung » OpenGL


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder 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.011s | 16 Queries | GZIP : On ]