In OpenGL, wie kann ich für das Fenster die Größe angepasst werden?

Question

Ich zeichne mehrere Formen (wie Kreise), die von der Fensterhöhe & Breite abgeschnitten werden. Da das Fenster immer bei einer bestimmten Größe beginnt, werden sie korrekt gezeichnet, aber wenn das Fenster in der Größe geändert wird, wird das Seitenverhältnis nach oben verschoben.

Wie kann ich die Formen unabhängig von der Fenstergröße richtig zeichnen?

Answer 1

Sie wollen nicht unbedingt die Größe der Objekte explizit auf der Fenstergröße abhängig machen.

Wie bereits von genpfault vorgeschlagen, passen Sie Ihre Projektionsmatrix immer an, wenn sich die Fenstergröße ändert.

Dinge auf Fenster Resize zu tun:

1. Ansichtsfenster einstellen:

   glViewPort(0,0, width, height)

2. Projektionsmatrix einstellen:

   glFrustum(left * ratio, right * ratio, bottom, top, nearClip,farClip)

   oder

   glOrtho(left * ratio, right * ratio, bottom, top, nearClip,farClip)

   oder

   gluOrtho2D(left * ratio, right * ratio, bottom, top)

   (unter der Annahme, dass left, right, bottom und top alle gleich sind und ratio=width/height)

Answer 2

Wenn Sie so etwas wie gluPerspective verwenden() verwenden, nur die Fensterbreite/Höhe-Verhältnis:

gluPerspective(60, (double)width/(double)height, 1, 256); 

Answer 3

Sie sollten eine Art von Fenster-Handler-Funktion Setup, die aufgerufen wird Immer wenn Ihr OpenGL-Fenster in der Größe geändert wird. Sie müssen auf den Fall achten, wenn aspectRatio> 1 ist und wenn aspectRatio < = 1 separat ist. Wenn dies nicht geschieht, kann dies dazu führen, dass die Geometrie nach einer Größenanpassung des Bildschirms nicht mehr angezeigt wird.

void windowResizeHandler(int windowWidth, int windowHeight){ 
    const float aspectRatio = ((float)windowWidth)/windowHeight; 
    float xSpan = 1; // Feel free to change this to any xSpan you need. 
    float ySpan = 1; // Feel free to change this to any ySpan you need. 

    if (aspectRatio > 1){ 
     // Width > Height, so scale xSpan accordinly. 
     xSpan *= aspectRatio; 
    } 
    else{ 
     // Height >= Width, so scale ySpan accordingly. 
     ySpan = xSpan/aspectRatio; 
    } 

    glOrhto2D(-1*xSpan, xSpan, -1*ySpan, ySpan, -1, 1); 

    // Use the entire window for rendering. 
    glViewport(0, 0, windowWidth, windowHeight); 
} 

Answer 4

Ich lerne opengl auch. Ich bin gestern mit diesem Problem konfrontiert worden und habe die richtige Antwort nicht gefunden. Heute habe ich das Problem gelöst. In meinem kleinen Programm ändert das Objekt seine Größe, wenn es die Fensterbreite oder -höhe ändert. Dies ist mein Code (bitte verzeihen Sie meine Fehler):

#include <GL/freeglut.h> 

void fnReshape(int ww, int hh) 
{ 
    GLdouble r; 
    if(hh == 0) 
    hh = 1.0; 
    if(hh > ww) 
    r = (double) hh/(double) ww; 
    else 
    r = (double) ww/(double) hh; 
    glViewport(0, 0, ww, hh); 
    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 
    if(hh > ww) 
    glFrustum(-1.0, 1.0, -1.0 * r, 1.0 * r, 2.0, 200.0); 
    else 
    glFrustum(-1.0 * r, 1.0 * r, -1.0, 1.0, 2.0, 200.0); 
} 
////////////////////////////////////////////////////////////////// 
void fnDisplay(void) 
{ 
    glClear(GL_COLOR_BUFFER_BIT); 
    glMatrixMode(GL_MODELVIEW); 
    glLoadIdentity(); 
    glTranslatef(0., 0., -5.); 
    glBegin(GL_QUAD_STRIP); 
    glColor3f(0., 0., 1.0); 
    glVertex3f(-1., -1., 0.); 
    glVertex3f(-1., 1., 0.); 
    glVertex3f(1., -1., 0.); 
    glVertex3f(1., 1., 0.); 
    glEnd(); 
    glutSwapBuffers(); 
} 
//////////////////////////////////////////////////////////// 
int main(int argc, char **argv) { 
    glutInit(&argc, argv); 
    glutInitDisplayMode(GLUT_RGBA |GLUT_DOUBLE); 
    glutInitWindowSize(500, 500); 
    glutCreateWindow("Sample window"); 
    glClearColor(1.0, 0, 0, 1.0); 
    glutDisplayFunc(fnDisplay); 
    glutReshapeFunc(fnReshape); 
    glutMainLoop(); 
    return 0; 
} 

Answer 5

Es gibt viele Methoden, das zu tun. Das folgende Beispiel zeigt Ihnen, wie ich es in meinen Projekten mache und wie es funktioniert. Das Beispiel zeigt Ihnen einfach eine rechteckige Box, die ihre Größe nicht ändert, wenn das Fenster die Größe ändert. Sie können es direkt in Ihrem Projekt kopieren und einfügen (man denkt, dass ich einen OPENGL Anfänger bin)

#include<windows.h> 
#include<glut.h> 

GLfloat x1=100.0f; 
GLfloat y1=150.0f; 
GLsizei rsize = 50; 

GLfloat xstep=1.0f; 
GLfloat ystep=1.0f; 

GLfloat windowWidth; 
GLfloat windowHeight; 


void scene(void){ 
    glClear(GL_COLOR_BUFFER_BIT); 
    glColor3f(1.0f,0.0f,0.0f); 

    glRectf(x1,y1,x1+rsize,y1-rsize); 

    glutSwapBuffers(); 
} 

void setupRc(void){ 

    glClearColor(0.0f,0.0f,1.0f,0.0f); 

} 

void changeSize(GLsizei w,GLsizei h){ 
    if(h==0) 
    h=1; 
    glViewport(0,0,w,h); 
    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 
    if(w>=h){ 
    windowWidth=250.0f*w/h; 
    windowHeight=250.f; 
    } 
    else{ 
    windowWidth=250.0f; 
    windowHeight=250.f*h/w; 
    } 

    glOrtho(0.0f,windowWidth,0.0f,windowHeight,1.0f,-1.0f); 


    glMatrixMode(GL_MODELVIEW); 
    glLoadIdentity(); 


} 




void main(void){ 

    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA); 

    glutCreateWindow("Rectangle"); 

    glutReshapeFunc(changeSize); 
    glutDisplayFunc(scene); 
    setupRc(); 

    glutMainLoop(); 

}