In OpenGL, come posso regolare la dimensione della finestra da ridimensionare?

Question

Sto disegnando diverse forme (come i cerchi) che sono fuoriuscite dalla larghezza della finestra &. Poiché la finestra inizia sempre con una determinata dimensione, vengono disegnate correttamente, ma quando la finestra viene ridimensionata, scompone il rapporto aspetto.

Come posso disegnare correttamente le forme, indipendentemente dalle dimensioni della finestra?

Answer 1

Lei sicuramente non si vuole fare la dimensione degli oggetti esplicitamente dipende dalla dimensione della finestra.

Come già suggerito da genpfault, regolare la matrice di proiezione ogni volta che le dimensioni della finestra cambiano.

cose da fare sulla finestra di ridimensionamento:

1. Regolare viewport:

   glViewPort(0,0, width, height)

2. Regolare matrice di proiezione:

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

   o

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

   o

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

   (supponendo che left, right, bottom e top sono tutti uguali e ratio=width/height)

Answer 2

Se stai usando qualcosa come gluPerspective() basta usare il rapporto larghezza/altezza della finestra:

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

Answer 3

è necessario impostare una sorta di funzione finestra gestore che si chiama ogni volta che la tua finestra OpenGL viene ridimensionata. È necessario occuparsi del caso quando aspectRatio> 1 e quando aspectRatio < = 1 separatamente. In caso contrario, la geometria potrebbe cadere fuori dallo schermo dopo un ridimensionamento dello schermo.

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

Anche io sto imparando opengl. Ho affrontato questo problema ieri e non ho trovato la risposta corretta. Oggi ho risolto il problema. Nel mio piccolo programma, l'oggetto cambia dimensione quando ridimensiona la larghezza della finestra o l'heigt. Questo è il mio codice (per favore, perdona i miei errori):

#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

Ci sono molti metodi per farlo. L'esempio seguente mostra come lo sto facendo nei miei progetti e nel suo funzionamento. L'esempio mostra semplicemente un rettangolo che non cambia le sue dimensioni quando la finestra viene ridimensionata. direttamente È possibile copiare e incollare nel vostro progetto (ritengo che io sono un principiante OpenGL)

#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(); 

}