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

Aktuelle Zeit: Fr Jul 18, 2025 21:07

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


Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 1
  [ 2 Beiträge ] 
  Vorheriges Thema | Nächstes Thema 
Autor Nachricht
Doomhammer
 Betreff des Beitrags: Abbildungsfehler - glViewport?
BeitragVerfasst: Fr Apr 06, 2007 14:47 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Jan 15, 2007 16:10
Beiträge: 24
Wohnort: bei Düsseldorf
Hallo zusammen,

erstmal sorry für die Überschrift, aber ich hab keine prägnante Formulierung gefunden.

Ich weiß leider auch nicht wo genau das Problem steckt, ich vermute glViewport, aber irgendwie kann es das auch nicht sein.

Ich habe die Kamera-Klasse von einem Nehe Tutorial für meine Zwecke abgeändert und in meine Anwendung integriert.
Ich setze mit gluPerspective die Projektionsmatrix und mit gluLookAt die Modelviewmatrix. Soweit so gut.


Leider befindet sich das gerenderte Ergebnis viel zu "hoch" im Bildschirm, wie es eigentlich sein müsste.

Ich habe ein Würfel in die Szene geladen und auch mittels GL_Lines ein Koordinatensystem gezeichnet. Der Ursprung liegt genau auf dem Sichtvektor der Kamera und müsste daher eigentlich ja in der Mitte des Bildschirms abgebildet werden. Hier ist er auch wieder nach oben verschoben.
Ich habe die ganze Szene in Maya mal nachgestellt und die Werte verglichen. Alles soweit richtig, nur dass das Bild nach oben verschoben ist, so dass der obere Bereich abgeschnitten wird.

Was kann dazu geführth aben, dass das rendering nach oben verrutscht ist ? wie kann ich den Fehler beheben ?

Danke für Eure Hilfe

Grüße
Chris
Hier der Programmcode. Wie gesagt, Position, Richtungs- und UpVektor der Kamera stimmen. Auch die Perspektive der gerenderten Szene stimmt.


Code:
  1.  
  2. void glCamera::SetPerspective(float Height, float Width)
  3. {
  4.     GLfloat Matrix[16];
  5.     glQuaternion q;
  6.  
  7.     //adjust the projection Matrix with gluPerspective
  8.     glMatrixMode( GL_PROJECTION );
  9.     glLoadIdentity();
  10.     glViewport(0, 0, Width,Height);
  11.  
  12.     //Get new values from the LUT Table
  13.     //float FOV = cameraEncoder-> getFieldOfView(ZoomEncoder, FocusEncoder);
  14.     //float NPS = cameraEncoder-> getNodalPointShift(ZoomEncoder, FocusEncoder);
  15.     float FOV = 60.0;
  16.     float NPS = 0.00;
  17.  
  18.     //Now set the new Field of View to the Viewport
  19.     gluPerspective(FOV, Width/Height, 0.01f, 1000.0f);
  20.  
  21.    
  22.  
  23.  
  24.     // Create a rotation matrix based on the recorded quaternion
  25.     q = m_qPitch;
  26.     q.CreateMatrix(Matrix);
  27.  
  28.  
  29.        
  30.     //Z-Vector
  31.     glVector Vector_Z;
  32.     Vector_Z.i = 0;
  33.     Vector_Z.j = 0;
  34.     Vector_Z.k = 1;
  35.     Vector_Z.l = 1;
  36.  
  37.     //Y-Vector
  38.     glVector Vector_Y;
  39.     Vector_Y.i = 0;
  40.     Vector_Y.j = 1;
  41.     Vector_Y.k = 0;
  42.     Vector_Y.l = 1;
  43.  
  44.  
  45.     //Calculates the Vector through the camera = Matrix * (0/0/1)
  46.     m_DirectionVector.i = Matrix[0]*Vector_Z.i + Matrix[4]*Vector_Z.j + Matrix[8]*Vector_Z.k + Matrix[12]*Vector_Z.l;
  47.     m_DirectionVector.j = Matrix[1]*Vector_Z.i + Matrix[5]*Vector_Z.j + Matrix[9]*Vector_Z.k + Matrix[13]*Vector_Z.l;
  48.     m_DirectionVector.k = Matrix[2]*Vector_Z.i + Matrix[6]*Vector_Z.j + Matrix[10]*Vector_Z.k + Matrix[14]*Vector_Z.l;
  49.     m_DirectionVector.l = Matrix[3]*Vector_Z.i + Matrix[7]*Vector_Z.j + Matrix[11]*Vector_Z.k + Matrix[15]*Vector_Z.l;
  50.  
  51.     //Point of interest
  52.     m_Center.x = m_DirectionVector.i + m_Position.x;
  53.     m_Center.y = m_DirectionVector.j + m_Position.y;
  54.     m_Center.z = m_DirectionVector.k + m_Position.z;
  55.  
  56.     //Calculates the Up-Vector = Matrix * (0/1/0)
  57.     m_UpVector.i = Matrix[0]*Vector_Y.i + Matrix[4]*Vector_Y.j + Matrix[8]*Vector_Y.k + Matrix[12]*Vector_Y.l;
  58.     m_UpVector.j = Matrix[1]*Vector_Y.i + Matrix[5]*Vector_Y.j + Matrix[9]*Vector_Y.k + Matrix[13]*Vector_Y.l;
  59.     m_UpVector.k = Matrix[2]*Vector_Y.i + Matrix[6]*Vector_Y.j + Matrix[10]*Vector_Y.k + Matrix[14]*Vector_Y.l;
  60.     m_UpVector.l = Matrix[3]*Vector_Y.i + Matrix[7]*Vector_Y.j + Matrix[11]*Vector_Y.k + Matrix[15]*Vector_Y.l;
  61.  
  62.     //NodalPointShift shifts the camera position on the z-axis
  63.     m_DirectionVector *= 1/m_DirectionVector.l;
  64.     m_DirectionVector *= 1/sqrt(m_UpVector.i*m_UpVector.i+ m_UpVector.j*m_UpVector.j+m_UpVector.k*m_UpVector.k);
  65.     m_DirectionVector *= NPS;
  66.     m_Position.x = m_Position.x + m_DirectionVector.i;
  67.     m_Position.y = m_Position.y + m_DirectionVector.j;
  68.     m_Position.z = m_Position.z + m_DirectionVector.k;
  69.  
  70.     // calculate the point above the camera
  71.     glPoint m_UpPoint;
  72.     m_UpPoint.x = m_Position.x + m_UpVector.i;
  73.     m_UpPoint.y = m_Position.y + m_UpVector.j;
  74.     m_UpPoint.z = m_Position.z + m_UpVector.k;
  75.    
  76.     //CLear frame buffer and depth buffer
  77.     glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
  78.     glEnable(GL_DEPTH_TEST);
  79.  
  80.  
  81.     //adjust the modelview matrix with gluLookAt
  82.     glMatrixMode( GL_MODELVIEW );
  83.     glLoadIdentity();
  84.  
  85.     gluLookAt(m_Position.x, m_Position.y, m_Position.z, m_Center.x, m_Center.z, m_Center.z, m_UpVector.i, m_UpVector.j, m_UpVector.k);
  86.  
  87.  
  88.    
  89. // set up coordinate system
  90.  
  91. glBegin(GL_LINES);
  92.   glColor3f(1,0,0); glVertex3f(-4.659 ,0.726 ,3.831 ); glVertex3f(0,0.726 ,3.831);
  93.   glColor3f(0,1,0); glVertex3f(-4.659 ,0.726 ,3.831); glVertex3f(-4.659 ,12,3.831);
  94.   glColor3f(0,0,1); glVertex3f(-4.659 ,0.726 ,3.831); glVertex3f(-4.659 ,0.726 ,0);
  95. glEnd();
  96.  
  97.  
  98.  
  99. }


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

Nach oben
 Profil  
Mit Zitat antworten  
Doomhammer
 Betreff des Beitrags:
BeitragVerfasst: Fr Apr 06, 2007 17:05 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Jan 15, 2007 16:10
Beiträge: 24
Wohnort: bei Düsseldorf
wer lesen kann ist klar im vorteil !

Code:
  1. gluLookAt(m_Position.x, m_Position.y, m_Position.z, m_Center.x, m_Center.z, m_Center.z, m_UpVector.i, m_UpVector.j, m_UpVector.k);


es muss dann natürlich auch

Code:
  1. m_Center.x, m_Center.[b]y[/b], m_Center.z


heißen...

Damit funktioniert es so wie gewünscht !

Danke an alle, die das hier durchgelesen haben....

Bis zum nächsten mal ....

damit [closed] bitte schließen[/b]
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 1
  [ 2 Beiträge ] 
Foren-Übersicht » Programmierung » OpenGL


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 3 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.008s | 14 Queries | GZIP : On ]