En OpenGL, comment puis-je régler pour le redimensionnement de fenêtre?

Je dessine plusieurs formes (telles que des cercles) qui sont assorties hors de la hauteur de la fenêtre & largeur. Depuis la fenêtre commence toujours à une taille donnée, ils sont dessinés correctement, mais lorsque la fenêtre est redimensionnée, il sème le ratio d'aspect.

Comment puis-je dessiner les formes correctement, indépendamment de la taille de la fenêtre?

OriginalL'auteur samoz | 2010-07-16

14

Vous ne voulez certainement pas à faire la taille de vos objets explicitement dépend de la taille de la fenêtre.

Comme l'a déjà suggéré genpfault, ajuster votre matrice de projection à chaque fois que la taille de la fenêtre change.

Choses à faire sur la fenêtre de redimensionnement:
1. Ajuster la fenêtre d'affichage
```
glViewport(0, 0, width, height)
```
2. Ajuster ciseaux rectangle (uniquement si vous avez GL_SCISSOR_TEST activé)
```
glScissor(0, 0, width, height)
```
3. Ajuster la matrice de projection
  
  En cas d'héritage (fixe fonction de pipeline), OpenGL, vous pouvez le faire de la manière suivante:
```
glFrustum(left * ratio, right * ratio, bottom, top, nearClip,farClip)
```
  ou
```
glOrtho(left * ratio, right * ratio, bottom, top, nearClip,farClip)
```
  ou
```
gluOrtho2D(left * ratio, right * ratio, bottom, top)
```
  (en supposant que left, right, bottom et top sont tous égaux et ratio=width/height)
L'usage de ciseaux influe également sur la redéfinition de la zone, si vous activez le clip rect en appelant glScissor(). Voir ceci.

OriginalL'auteur Greg S
4

Si vous utilisez quelque chose comme gluPerspective() suffit d'utiliser la fenêtre de rapport largeur/hauteur:
```
gluPerspective(60, (double)width/(double)height, 1, 256);
```
OriginalL'auteur genpfault

Vous devez configurer une sorte de gestionnaire de fenêtre de la fonction qui est appelée à chaque fois que votre OpenGL fenêtre est redimensionnée. Vous avez besoin de prendre soin de l'affaire quand aspectRatio > 1, et quand aspectRatio <= 1 séparément. Ne pas le faire peut entraîner la géométrie de tomber hors de l'écran après un redimensionnement de l'écran.

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);
}

OriginalL'auteur Dustin Biser

Je suis en train d'apprendre opengl trop. J'ai été confronté à ce problème hier et je n'ai pas trouvé la bonne réponse. Aujourd'hui, j'ai à résoudre le problème. Dans mon petit programme, l'objet change de taille lors du redimensionnement de la fenêtre de modification de la largeur ou de la heigt. C'est mon code (s'il vous plaît, pardonnez-moi mes erreurs):

#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;
}

OriginalL'auteur José Antonio López Cano

Il existe de nombreuses méthodes pour le faire.
L'exemple suivant vous montre comment je vais le faire dans mes projets et son travail.
L'exemple montre simplement un rectangle qui ne sont pas des changements de taille lorsque la fenêtre est redimensionnée. Vous pouvez directement copier et coller dans votre projet(considérez que je suis un openGl débutant)

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

}

OriginalL'auteur Sathsara AM

Vous devez vous connecter pour publier un commentaire.