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

Aktuelle Zeit: Fr Apr 19, 2024 18:47

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


Ein neues Thema erstellen Auf das Thema antworten  Seite 2 von 2
  [ 26 Beiträge ]  Gehe zu Seite Vorherige  1, 2
  Vorheriges Thema | Nächstes Thema 
Autor Nachricht
Litefora
BeitragVerfasst: Mo Apr 08, 2013 07:34 
Offline
DGL Member

Registriert: Do Mär 21, 2013 14:57
Beiträge: 51
Programmiersprache: C#,C++
Ja, im Prinzip mach ich das ja ähnlich. Nur, dass ich das Ganze noch nicht in eine Klasse gepackt habe.
Danke für die Antwort, aber wirklich weiter gebracht hat mich das nicht. ^^

Aber das Problem mit den Clipping planes existiert ja im Prinzip nur, weil ich über den Faktor beim forward
Vektor an das Objekt bzw. den Modelview-Ursprung heranzoomen möchte, was unverständlicher Weiße
nicht funktioniert. Wie bereits erwähnt, verschieben sich anscheinend nur die Clipping planes wenn ich in
meiner manuell erstellten Modelview-Matrix den EyeVektor (forward) mit einem Faktor multipliziere! Zur
Zeit hantiere ich im Bereich 1.0 bis 0.1, da mein Objekt entsprechend klein ist. Aber wie gesagt, eine An-
näherung an das Objekt ist nicht zu vermerken!

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.                 this.theta += dx * Math.PI / 180.0;
  17.                 this.phi += dy * Math.PI / 180.0;
  18.  
  19.                 // Set borders from 0 to 360°.
  20.                 if (this.theta > 2 * Math.PI)
  21.                     this.theta -= 2 * Math.PI;
  22.                 if (this.theta < 0)
  23.                     this.theta += 2 * Math.PI;
  24.  
  25.                 // Set borders from 90 to -90°
  26.                 if (this.phi > Math.PI/2)
  27.                     this.phi = Math.PI/2;
  28.                 if (this.phi < -Math.PI/2)
  29.                     this.phi = -Math.PI/2;
  30.  
  31.                 // Angle output.
  32.                 ThetaOutput.Text = "Theta: " + this.theta;
  33.                 PhiOutput.Text = "Phi: " + this.phi;
  34.  
  35.                 // Compute position vector.
  36.                 Vector3d forward = new Vector3d(Math.Sin(this.theta) * Math.Cos(this.phi),
  37.                                                 -Math.Sin(this.phi),
  38.                                                 Math.Cos(this.theta) * Math.Cos(this.phi)
  39.                                                 );
  40.  
  41.                 // Switch do model matrix.
  42.                 GL.MatrixMode(MatrixMode.Modelview);
  43.  
  44.                 GL.LoadIdentity();
  45.  
  46.                 // Compute new modelview matrix.
  47.                 Matrix4d modelview = Matrix4d.LookAt(Vector3d.Zero + forward * 0.1, Vector3d.Zero, Vector3d.UnitY);
  48.  
  49.                 // Set new modelview matrix.
  50.                 GL.LoadMatrix(ref modelview);
  51.  
  52.                 // Update mouse position.
  53.                 mouse_previous.X = mouse_current.X;
  54.                 mouse_previous.Y = mouse_current.Y;
  55.             }
  56.         }


Ich bin bereits am verzweifeln, da logisches Denken mich bei dieser Funktion nicht weiter bringt. Entweder verstehe ich an der
LookAt-Funktion grundlegend falsch oder sie macht wirklich nicht das, was einem in allen Foren beschrieben wird, bzw. was ihr
Aufbau sugeriert.

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)
Nach oben
 Profil  
Mit Zitat antworten  
Litefora
BeitragVerfasst: Di Apr 09, 2013 14:25 
Offline
DGL Member

Registriert: Do Mär 21, 2013 14:57
Beiträge: 51
Programmiersprache: C#,C++
Schade, dass mir niemand helfen kann.

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

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java
[edit]nachdem ich nun diesen schönen artikel geschrieben, ist mir aufgefallen, dass LookAt ja evtl die gleichen Parameter haben könnte wie gluLookAt. Ich lasse die Antwort aber trotzdem mal stehen, vllt ist dein LookAt doch genau dieses welches das mir gerade vorschwebte und nur die Rotationsmatrix setzt.[/edit]

Code:
  1. Matrix4d modelview = Matrix4d.LookAt(Vector3d.Zero + forward * 0.1, Vector3d.Zero, Vector3d.UnitY);

ich schätze mal dass LookAt sehr gerne normalisierte Forward, Left/Right und Up-Vektoren hätte.
Vector3f.Zero ist schonmal nicht normalisiert.
Und Vector3f.Zero + forward * 0.1 kann auch nicht normalisiert sein.

Left/Right kannst du dir aus einem Kreuzprodukt von forward mit up erstellen. Left/Right je nach Reihenfolge. Siehe Kreuzprodukt.
Um anschliessend noch einen ordentlichen Up-Vektor zu bekommen, kannst du diesen einfach aus einem Kreuzprodukt von Left/Right und Forward erzeugen.

Somit hast du 3 Vektoren die alle im rechten Winkel aufeinander stehen. Siehe rechtshändiges Koordinatensystem

Muss selber immer rumprobieren, bis ich die richtige Reihenfolge der Kreuzprodukte habe. :)

_________________
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 12, 2013 08:55 
Offline
DGL Member

Registriert: Do Mär 21, 2013 14:57
Beiträge: 51
Programmiersprache: C#,C++
Verzeih mir die dumme Frage: Aber wie normalisiere ich Vektoren!?
Bin erst ein Frischling in Sachen OpenGL.

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

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++
Länge des Vektors ermitteln und dann alle Komponenten dadurch teilen :

Code:
  1. l := Sqrt(v.x*v.x + v.y*v.y + v.z*v.z);
  2. v.x := v.x / l;
  3. ...
  4.  

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)
Nach oben
 Profil  
Mit Zitat antworten  
Lord Horazont
BeitragVerfasst: Sa Apr 13, 2013 11:40 
Offline
DGL Member
Benutzeravatar

Registriert: Do Sep 02, 2004 19:42
Beiträge: 4158
Programmiersprache: FreePascal, C++
… und die division durch null abfangen, wenn der Vektor (0,0,0) ist.

grüße

_________________
If you find any deadlinks, please send me a notification – Wenn du tote Links findest, sende mir eine Benachrichtigung.
current projects: ManiacLab; aioxmpp
zombofant network • my photostream
„Writing code is like writing poetry“ - source unknown

„Give a man a fish, and you feed him for a day. Teach a man to fish and you feed him for a lifetime. “ ~ A Chinese Proverb
Nach oben
 Profil  
Mit Zitat antworten  
Litefora
BeitragVerfasst: Di Apr 30, 2013 10:32 
Offline
DGL Member

Registriert: Do Mär 21, 2013 14:57
Beiträge: 51
Programmiersprache: C#,C++
So, ich hatte jetzt endlich mal Zeit eure Tipps auszuprobieren. Leider funktioniert entweder nichts davon
oder ich mach wiedermal was falsch. Hier mal mein Code:

Code:
  1.  
  2.           private void computeCamPos(Point mouse_current, Point mouse_previous)
  3.           {
  4.             // Compute moving distance depending on mouse speed.
  5.             double dx = mouse_current.X - mouse_previous.X;
  6.             dx *= mouse_speed;
  7.             double dy = mouse_current.Y - mouse_previous.Y;
  8.             dy *= mouse_speed;
  9.  
  10.             // Get angle in rad.
  11.             this.theta += dx * Math.PI / 180.0;
  12.             this.phi += dy * Math.PI / 180.0;
  13.  
  14.             // Set borders from 0 to 360°.
  15.             if (this.theta > 2 * Math.PI)
  16.                 this.theta -= 2 * Math.PI;
  17.             if (this.theta < 0)
  18.                 this.theta += 2 * Math.PI;
  19.  
  20.             // Set borders from 90 to -90°
  21.             if (this.phi > Math.PI / 2)
  22.                 this.phi = Math.PI / 2;
  23.             if (this.phi < -Math.PI / 2)
  24.                 this.phi = -Math.PI / 2;
  25.            
  26.             // Normalize target vector.
  27.             double x = Math.Sin(this.theta) * Math.Cos(this.phi);
  28.             double y = -Math.Sin(this.phi);
  29.             double z = Math.Cos(this.theta) * Math.Cos(this.phi);
  30.  
  31.             double length = Math.Sqrt((x*x) + (y*y) + (z*z));
  32.  
  33.             double norm_x = x;
  34.             double norm_y = y;
  35.             double norm_z = z;
  36.  
  37.             if (length != 0)
  38.             {
  39.                 norm_x = x / length;
  40.                 norm_y = y / length;
  41.                 norm_z = z / length;
  42.             }
  43.  
  44.             // Compute position vector.
  45.             forward = new Vector3d()
  46.             {
  47.                 X = norm_x,
  48.                 Y = norm_y,
  49.                 Z = norm_z
  50.             };
  51.         }
  52.  
  53.         public void setCamPos(double zoom, Point mouse_current, Point mouse_previous, ref GLControl glControl1)
  54.         {
  55.             Point mouseCurrent = mouse_current;
  56.             Point mousePrevious = mouse_previous;
  57.  
  58.             this.computeCamPos(mouseCurrent, mousePrevious);
  59.  
  60.             // Switch do model matrix.
  61.             GL.MatrixMode(MatrixMode.Modelview);
  62.  
  63.             GL.LoadIdentity();
  64.  
  65.             Vector3d.Zero.Normalize();
  66.             Vector3d.UnitY.Normalize();
  67.  
  68.             // Compute new modelview matrix.
  69.             Matrix4d modelview = Matrix4d.LookAt(Vector3d.Zero + this.forward * 0.1, Vector3d.Zero, Vector3d.UnitY);
  70.  
  71.             // Set new modelview matrix.
  72.             GL.LoadMatrix(ref modelview);
  73.  
  74.             this.setUpViewPort(ref glControl1);
  75.         }
  76.  

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

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java
Code:
  1. Vector3d.Zero.Normalize();
  2. Vector3d.UnitY.Normalize();

Warum normalisierst du statics? Normalisieren bedeutet die Gesamtlänge eines Vektors auf 1 (Einheitsvektor / Unitvector) zu bringen aber die Richtung beizubehalten.
Zero sollte eine länge von 0 haben^^
UnitY meint, dass der Vektor eine Länge von 1 hat und exakt in Richtung der Y-Achse zeigt also (0, 1, 0).

Code:
  1.  
  2. // Normalize target vector.
  3. double x = Math.Sin(this.theta) * Math.Cos(this.phi);
  4. double y = -Math.Sin(this.phi);
  5. double z = Math.Cos(this.theta) * Math.Cos(this.phi);
  6.  
  7. double length = Math.Sqrt((x*x) + (y*y) + (z*z));
  8.  
  9. double norm_x = x;
  10. double norm_y = y;
  11. double norm_z = z;
  12.  
  13. if (length != 0)
  14. {
  15.   norm_x = x / length;
  16.   norm_y = y / length;
  17.   norm_z = z / length;
  18. }
  19.  


Warum nimmst du hier nicht die normalize() Funktion deiner Vector3d Klasse?

Code:
  1.  
  2. // Normalize target vector.
  3. Vector3d vector = new Vector3d();
  4. vector.x = Math.Sin(this.theta) * Math.Cos(this.phi);
  5. vector.y = -Math.Sin(this.phi);
  6. vector.z = Math.Cos(this.theta) * Math.Cos(this.phi);
  7.  
  8. vector.normalize();
  9.  

Wobei der Vektor, der hier durch Sinus und Cosinus berechnet wird schon normalisiert sein sollte.

Code:
  1. Vector3d.Zero + this.forward * 0.1

Du machst dir die Mühe den forward Vektor zu normalisieren und übergibst dann nur 10% davon?
Mich würde mal der Quelltext zu deiner Matrix4d.LookAt Funktion interessieren, je nachdem wie das dort implementiert ist. Kannst du den mal posten/verlinken?

_________________
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: Do Mai 02, 2013 08:52 
Offline
DGL Member

Registriert: Do Mär 21, 2013 14:57
Beiträge: 51
Programmiersprache: C#,C++
Der Wert 0.1 sollte eigentlich durch die Variable "zoom" ersetzt werden um praktisch die Distanz
zum Eye-Punkt zu verringern - eben um einen Zoom zu realisieren. Aber komischer Weise funktioniert
das nicht, da dann der Körper abgeschnitten wird an vielen Stellen, den Wert 0.1 habe ich durch
ausprobieren ermittelt, da bei diesem die gesamte Scene dargestellt wird und nicht hinter clipping
planes verschwindet, die aber komischer weise auf near = 0.0 und far = 100.0 gesetzt habe. Mein
gezeichnetes Objekt befindet sich größentechnisch im Bereich von -1.0 bis 1.0 in x-,y- und z-Richtung.

Wie die LookAt - Funktion implementiert ist kann ich nicht einsehen, da diese in der OpenTK library
definiert ist.

Das normalize hatte ich nur testweise drin, mir ist auch klar, dass diese schon normiert sein sollten
bzw. die länge des Vektors zero "0" sein sollte. Aber im Moment bin ich eben am Ende mit meinem
Latein, weswegen ich alles ausprobiere ;D .

Mein Ziel ist es, mit dem folgenden Code, die Kamera zu drehen (Kugelkoordinaten) per Maus - was
im Moment funktioniert - und an den Eye-Punkt heran zu zoomen, was komischer Weise nicht funktioniert
für mich scheinen sich nur die clipping planes zu verschieben. Außerdem rufe ich die setUpViewPort - Funktion
auch beim Resizen des Fensters auf und möchte verhindern, dass der Körper sich in Höhe und Breite strekt
bzw. quetscht, was ich auch irgendwie nicht auf die Reihe bekokmme.

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)
Nach oben
 Profil  
Mit Zitat antworten  
Litefora
BeitragVerfasst: Do Mai 02, 2013 08:53 
Offline
DGL Member

Registriert: Do Mär 21, 2013 14:57
Beiträge: 51
Programmiersprache: C#,C++
Mein Source Code für die Kamera und ViewPort - Funktionen sieht wie folgt aus:
Code:
  1.  
  2. public void setUpViewPort(ref GLControl glControl1)
  3.         {
  4.             // Compute the size of the glControl1.
  5.             int width = glControl1.Width;
  6.             int height = glControl1.Height;
  7.  
  8.             // Choose Matrix.
  9.             GL.MatrixMode(MatrixMode.Projection);
  10.  
  11.             // Tell OpenGL how to compute pixels to coordinates.
  12.             GL.Viewport(0, 0, width, height);
  13.  
  14.             double frus_width = (width / height) * 600;
  15.             // Reset camera.
  16.             GL.LoadIdentity();
  17.            
  18.             // Generating a perspective matrix.
  19.             //Matrix4d perspective = Matrix4d.Perspective(((Math.PI / 180) * 45.0), (width / height), 0.0, 1000.0);
  20.             Matrix4d frustrum = Matrix4d.Frustum(600, 600, frus_width, frus_width, 0.0, 100.0);
  21.  
  22.             // Multiplying the projection matrix with the perspective one.
  23.             //GL.LoadMatrix(ref perspective);
  24.             GL.LoadMatrix(ref frustrum);
  25.         }
  26.  
  27. private void computeCamPos(Point mouse_current, Point mouse_previous)
  28.         {
  29.             // Compute moving distance depending on mouse speed.
  30.             double dx = mouse_current.X - mouse_previous.X;
  31.             dx *= mouse_speed;
  32.             double dy = mouse_current.Y - mouse_previous.Y;
  33.             dy *= mouse_speed;
  34.  
  35.             // Get angle in rad.
  36.             this.theta += dx * Math.PI / 180.0;
  37.             this.phi += dy * Math.PI / 180.0;
  38.  
  39.             // Set borders from 0 to 360°.
  40.             if (this.theta > 2 * Math.PI)
  41.                 this.theta -= 2 * Math.PI;
  42.             if (this.theta < 0)
  43.                 this.theta += 2 * Math.PI;
  44.  
  45.             // Set borders from 90 to -90°
  46.             if (this.phi > Math.PI / 2)
  47.                 this.phi = Math.PI / 2;
  48.             if (this.phi < -Math.PI / 2)
  49.                 this.phi = -Math.PI / 2;
  50.            
  51.             // Normalize target vector.
  52.             double x = Math.Sin(this.theta) * Math.Cos(this.phi);
  53.             double y = -Math.Sin(this.phi);
  54.             double z = Math.Cos(this.theta) * Math.Cos(this.phi);
  55.  
  56.             double length = Math.Sqrt((x*x) + (y*y) + (z*z));
  57.  
  58.             double norm_x = x;
  59.             double norm_y = y;
  60.             double norm_z = z;
  61.  
  62.             if (length != 0)
  63.             {
  64.                 norm_x = x / length;
  65.                 norm_y = y / length;
  66.                 norm_z = z / length;
  67.             }
  68.  
  69.             // Compute position vector.
  70.             forward = new Vector3d()
  71.             {
  72.                 X = norm_x,
  73.                 Y = norm_y,
  74.                 Z = norm_z
  75.             };
  76.         }
  77.  
  78. public void setCamPos(double zoom, Point mouse_current, Point mouse_previous, ref GLControl glControl1)
  79.         {
  80.             Point mouseCurrent = mouse_current;
  81.             Point mousePrevious = mouse_previous;
  82.  
  83.             this.computeCamPos(mouseCurrent, mousePrevious);
  84.  
  85.             this.setUpViewPort(ref glControl1);
  86.  
  87.             // Switch do model matrix.
  88.             GL.MatrixMode(MatrixMode.Modelview);
  89.  
  90.             // Compute new modelview matrix.
  91.             Matrix4d modelview = Matrix4d.LookAt(Vector3d.Zero + this.forward * 0.1, Vector3d.Zero, Vector3d.UnitY);
  92.  
  93.             // Set new modelview matrix.
  94.             GL.LoadMatrix(ref modelview);
  95.         }
  96.  


Das ist soz. die Hauptschleife:
Code:
  1.  
  2.  private void glControl1_Paint(object sender, PaintEventArgs e)
  3.         {
  4.             // Safety test accessing glControl1.
  5.             if (!this.loaded)
  6.                 return;
  7.  
  8.             // Clear color and depth buffer.
  9.             GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
  10.  
  11.             // Chosing drawing perspective.
  12.             GL.MatrixMode(MatrixMode.Projection);
  13.  
  14.             // Reset drawing perspective.
  15.             GL.LoadIdentity();
  16.  
  17.             // *************************************************
  18.             // Add light.
  19.             // *************************************************
  20.             this.Scene.addAmbientLight();
  21.  
  22.             // *************************************************
  23.             // Draw the see saw.
  24.             // *************************************************
  25.             this.SeeSaw.drawSeeSawTube();
  26.  
  27.             // **********************************************************
  28.             // Start movement.
  29.             // **********************************************************
  30.             if (this.play == true)
  31.                 this.Moving.openMovementBlock();
  32.  
  33.             // *************************************************
  34.             // Draw the fidge body.
  35.             // *************************************************
  36.             this.Body.drawBody();
  37.  
  38.             // *************************************************
  39.             // Draw the wound tube.
  40.             // *************************************************
  41.             GL.Disable(EnableCap.Lighting);
  42.             this.Moving.drawWoundTube();
  43.            
  44.             // **********************************************************
  45.             // End movement.
  46.             // **********************************************************
  47.             if (this.play == true)
  48.                 this.Moving.closeMovementBlock();
  49.  
  50.             // *************************************************
  51.             // Draw trajectory.
  52.             // *************************************************
  53.             this.Moving.drawTrajectory();
  54.  
  55.             // *************************************************
  56.             // Draw axes and the grid.
  57.             // *************************************************
  58.             this.Scene.drawGrid();
  59.             this.Scene.drawAxes();
  60.  
  61.             // Display the 3D scene.
  62.             this.glControl1.SwapBuffers();
  63.         }
  64.  



Die Kamerafunktionen werden im Mouse_Move - Event aufgerufen.

Ich hab jetzt auch mal händisch verschiedene Werte für den Z - Achsenabschnitt des forward - Vektors eingegeben und dabei
x und y auf 0 gesetzt, nur um zu sehen ob ich näher an den blickpunkt herankomme. Ergebnis - man kommt nicht näher. Langsam
begreife ich es nicht mehr. Zusätzlich spielte ich noch mit Skalierungsmatrizen herum, jedoch wurde die Ansicht beim Drehen der
Kamera um das Objekt wieder zurückgesetzt, spricht zur Anfangsskalierung. Solange ich die Ansich nicht drehte wurde die Modelview
Matrix entsprechen skaliert.

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)
Nach oben
 Profil  
Mit Zitat antworten  
Litefora
BeitragVerfasst: Mo Mai 06, 2013 14:35 
Offline
DGL Member

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

mein Problem hat sich heute gelöst. Ich habe einige eurer Vorschläge übernommen und schnell zum Test ein kleines simples Programm
mit einem Würfel geschrieben, dort dann die Kameralösung mit Matrix4d.LookAt implementiert. Funktionierte einwandfrei - was mich zum
staunen brachte. Also hab ich mein rießen Projekt Stück für Stück mit dem Testproramm verglichen, bis mir auffiel, dass ich im Paint - Event
(bitte jetzt nicht lachen - bin armer Anfänger ;D) die Projection - Matrix nochmals ausgewählt habe und über GL.LoadIdentity() durch eine Einheits-
matrix ersetzt habe! Bitte fragt mich jetzt nicht warum ich das tat.. ich lerne erst mit dieser Library umzugehen und sie zu verstehen.

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)
Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  Seite 2 von 2
  [ 26 Beiträge ]  Gehe zu Seite Vorherige  1, 2
Foren-Übersicht » Programmierung » OpenGL


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 50 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.141s | 17 Queries | GZIP : On ]