Was die OpenGL-Koordinaten sind? Ignorieren OpenGL-Fenster Größe

Ich habe gerade den Versuch gestartet zu folow einfachen "ziehen-cube" openGl tutorial. Nach dem endgültigen Sieg über erste OpenGL zu arbeiten, ich habe noch sehr veird Ergebnisse. Mein problem ist, dass die Objekte neigen dazu, um die Größe sich entsprechend der Fenstergröße. Stattdessen möchte ich die Größe des Fensters bestimmen, die rendering-Bereich - je größer das Fenster, desto mehr können Sie sehen.

Hier sind einige screenshots des Größenänderung:

Normale Größe

Geändert

Bilder werden als links absichtlich!

Diese auto-resizing-Verhalten mit sich bringt, eine Frage, was die Koordinaten in OpenGL sind.

  • Haben Sie einen Blick auf dieses question. Ich denke, es behandelt, was Sie gefragt haben.
InformationsquelleAutor Tomáš Zato | 2013-03-31
  1. 2

    Erste Sache, zum im Verstand zu halten: OpenGL ist ein drawing-API. Es nicht pflegen eine Szene oder sowas.

    Also, was OpenGL macht, ist, er ordnet geometrie-Eingabe von Koordinaten in form von vertex-Attributen, um Platz auf dem Bildschirm. In der alten Feste Funktion es gibt eine spezielle vertex-Attribut namens "vertex-position" oder nur kurz "vertex" (der eigentliche Scheitelpunkt ist mehr als nur die position).

    Die position verwandelt sich zum Fenster Raum in eine drei-Schritt-Prozess:

    1. Transformation in den Blick/Augen-Abstand: Diese erfolgt durch die Multiplikation der vertex-position mit der modelview-matrix.

    Bestimmten weiteren Berechnungen, wie die Beleuchtung die Berechnung erfolgt in view-space.

    2. Transformation in clip-space: Der Weltraum-position verwandelt sich in clip-space. Dies ist in der Regel als die Projektion und treffend die matrix beschreibt diese transformation wird als die Projektions-matrix

    Im clip-Raum einige Besondere Dinge passieren, zusammengefasst als eine Beschneidung, die Sie nicht haben, um über sorgen noch.

    3. Im letzten Schritt verwandelt sich der beschnittene geometrie in normalisierten gerätekoordinaten (NDC). NDC-space ist praktisch eine 1:1-Zuordnung in Richtung der viewport, d.h. die Grenzen des NDC Volumen entsprechen direkt den offset und die dimension des viewport-set mit glViewport.

    Sie können nicht ändern die Art und Weise der 3. Schritt passiert, und der 1. Schritt ist reserviert für die Umwandlung der Dinge in Aussicht Raum. Also keine Anpassungen geschehen muss im 2. Schritt.

    So, hier ist, was Sie zu tun haben: Die Projektion der Grenzen muss direkt proportional zu der viewport-Blöcke. Wie dies zum Beispiel

    glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-width/2, width/2, -height/2, height/2, -1, 1);

    Oh, und nur auf einen Allgemeinen Hinweis: Sie sollten immer setzen Sie den viewport und Projektion setup in der Zeichnung Funktion zu. Wenn Sie sehen, ein tutorial, stellt diese Aussagen in einem Fenster-resize-handler, ignorieren Sie es und tun Sie es einfach in die Zeichnung code sowieso. Langfristig ist dies wirklich eine Vereinfachung.

    • Ich mag Ihren Allgemeinen Hinweis, aber mein problem ist, dass ich hav absoluely keine Ahnung, wie man die Maße der Fenster (wird von google, aber ich habe Angst, dass der neue böse Funktionen, die bereit sind, mir zu zeigen, wie lahm ich bin) und auch, wie man diese auf gluPerspective (fand, dass auf das internet während der Wartezeit für Antworten), die dauert nur Breite/Höhe - so vergrößern Ursache zoom (vielleicht etwas übersetzen kann verwendet werden, aber ist das richtig?).
    • gut, genpfault geschrieben, was Sie erklärt haben, so meine Ressourcen sind abgeschlossen. Danke 🙂
    • Maße der Fenster sind außerhalb der Reichweite von OpenGL. Wahrscheinlich bist du mit einem framework wie GLFW, GLUT oder SDL (tutorial verlinkte verwendet GLUT). glutGet(GLUT_WINDOW_WIDTH) und glutGet(GLUT_WINDOW_HEIGHT) sind das, was du bist suchen für.
    InformationsquelleAutor datenwolf
  2. 1

    Der interessante Teil:

    glMatrixMode( GL_PROJECTION );
glLoadIdentity();
double w = glutGet( GLUT_WINDOW_WIDTH ) / 300.0;
double h = glutGet( GLUT_WINDOW_HEIGHT ) / 300.0;
glOrtho( -1 * w, 1 * w, -1 * h, 1 * h, 10, -10);

glMatrixMode( GL_MODELVIEW );
glLoadIdentity();

    Im Kontext:

    #include <GL/glut.h>

void display();
void specialKeys();

double rotate_y=0; 
double rotate_x=0;

void display(){
   // Clear screen and Z-buffer
  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

  glMatrixMode( GL_PROJECTION );
  glLoadIdentity();
  double w = glutGet( GLUT_WINDOW_WIDTH ) / 300.0;
  double h = glutGet( GLUT_WINDOW_HEIGHT ) / 300.0;
  glOrtho( -1 * w, 1 * w, -1 * h, 1 * h, 10, -10);

  glMatrixMode( GL_MODELVIEW );
  glLoadIdentity(); 

  //Rotate when user changes rotate_x and rotate_y
  glRotatef( rotate_x, 1.0, 0.0, 0.0 );
  glRotatef( rotate_y, 0.0, 1.0, 0.0 );

  //Multi-colored side - FRONT
  glBegin(GL_POLYGON);

  glColor3f( 1.0, 0.0, 0.0 );     glVertex3f(  0.5, -0.5, -0.5 );      //P1 is red
  glColor3f( 0.0, 1.0, 0.0 );     glVertex3f(  0.5,  0.5, -0.5 );      //P2 is green
  glColor3f( 0.0, 0.0, 1.0 );     glVertex3f( -0.5,  0.5, -0.5 );      //P3 is blue
  glColor3f( 1.0, 0.0, 1.0 );     glVertex3f( -0.5, -0.5, -0.5 );      //P4 is purple

  glEnd();

  //White side - BACK
  glBegin(GL_POLYGON);
  glColor3f(   1.0,  1.0, 1.0 );
  glVertex3f(  0.5, -0.5, 0.5 );
  glVertex3f(  0.5,  0.5, 0.5 );
  glVertex3f( -0.5,  0.5, 0.5 );
  glVertex3f( -0.5, -0.5, 0.5 );
  glEnd();

  //Purple side - RIGHT
  glBegin(GL_POLYGON);
  glColor3f(  1.0,  0.0,  1.0 );
  glVertex3f( 0.5, -0.5, -0.5 );
  glVertex3f( 0.5,  0.5, -0.5 );
  glVertex3f( 0.5,  0.5,  0.5 );
  glVertex3f( 0.5, -0.5,  0.5 );
  glEnd();

  //Green side - LEFT
  glBegin(GL_POLYGON);
  glColor3f(   0.0,  1.0,  0.0 );
  glVertex3f( -0.5, -0.5,  0.5 );
  glVertex3f( -0.5,  0.5,  0.5 );
  glVertex3f( -0.5,  0.5, -0.5 );
  glVertex3f( -0.5, -0.5, -0.5 );
  glEnd();

  //Blue side - TOP
  glBegin(GL_POLYGON);
  glColor3f(   0.0,  0.0,  1.0 );
  glVertex3f(  0.5,  0.5,  0.5 );
  glVertex3f(  0.5,  0.5, -0.5 );
  glVertex3f( -0.5,  0.5, -0.5 );
  glVertex3f( -0.5,  0.5,  0.5 );
  glEnd();

  //Red side - BOTTOM
  glBegin(GL_POLYGON);
  glColor3f(   1.0,  0.0,  0.0 );
  glVertex3f(  0.5, -0.5, -0.5 );
  glVertex3f(  0.5, -0.5,  0.5 );
  glVertex3f( -0.5, -0.5,  0.5 );
  glVertex3f( -0.5, -0.5, -0.5 );
  glEnd();

  glFlush();
  glutSwapBuffers();
}

void specialKeys( int key, int x, int y ) {
   // Right arrow - increase rotation by 5 degree
  if (key == GLUT_KEY_RIGHT)
    rotate_y += 5;

  // Left arrow - decrease rotation by 5 degree
  else if (key == GLUT_KEY_LEFT)
    rotate_y -= 5;

  else if (key == GLUT_KEY_UP)
    rotate_x += 5;

  else if (key == GLUT_KEY_DOWN)
    rotate_x -= 5;

  // Request display update
  glutPostRedisplay();
}

int main(int argc, char* argv[]){
  // Initialize GLUT and process user parameters
  glutInit(&argc,argv);

  // Request double buffered true color window with Z-buffer
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

  //Create window
  glutCreateWindow("Awesome Cube");

  // Enable Z-buffer depth test
  glEnable(GL_DEPTH_TEST);

  //Callback functions
  glutDisplayFunc(display);
  glutSpecialFunc(specialKeys);

  // Pass control to GLUT for events
  glutMainLoop();

  // Return to OS
  return 0;
}
    • Danke!!! Es gibt eine Menge inspiration für mich in diesem code 🙂 ich werde versuchen es anzuwenden.
    • Darf ich Fragen, warum glMatrixMode wird zweimal aufgerufen? Und warum die Größe der Fenster ist geteilt durch 300?
    • Einmal zu wechseln, um die projection-matrix-stack und einmal zum Schalter, um die modelview-stack. Könntest du technisch mit einem aber Sie sollten wirklich nicht tun. GLUT standardmäßig auf 300x300 pixel, windows (und Sie nicht überschreiben via glutInitWindowSize()) so dass ich dachte, das ist die Größe, die Sie wollte-stick mit.
    InformationsquelleAutor genpfault
Schreibe einen Kommentar