Comment utiliser plusieurs fenêtres en OpenGL?

Question

Je dois montrer le même objet en OpenGL dans deux différentes fenêtres, par exemple, en utilisant une projection orthographiques et l'autre en utilisant la perspective. Pour ce faire, dois-je attirer à nouveau l'objet après chaque appel à glViewport ()?

Answer 1

Nehe a un bon tutoriel sur la façon de faire , et son site est généralement une bonne ressource pour les questions OpenGL.

Answer 2

 // normal mode
  if(!divided_view_port)
    glViewport(0, 0, w, h);
else
{
    // right bottom
    glViewport(w/2, h/2, w, h);
    glLoadIdentity ();
    gluLookAt(5.0f, 5.0f, 5.0f,
              0.0f, 0.0f, 0.0f,
              0.0f, 1.0f, 0.0f);

    display();

    // left bottom
    glViewport(0, h/2, w/2, h);
    glLoadIdentity();
    gluLookAt (5.0f, 0.0f, 0.0f,
              0.0f, 0.0f, 0.0f,
              0.0f, 1.0f, 0.0f);

    display();

    // top right
    glViewport(w/2, 0, w, h/2);
    glLoadIdentity();
    gluLookAt(0.0f, 0.0f, 5.0f,
              0.0f, 0.0f, 0.0f,
              0.0f, 1.0f, 0.0f);

    display();

    // top left
    glViewport(0, 0, w/2, h/2);
    glLoadIdentity();
    gluLookAt(0.0f, 5.0f, 0.0f,
              0.0f, 0.0f, 0.0f,
              0.0f, 1.0f, 0.0f);

    display();
}
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

if (w <= h)
    glOrtho(-2.0, 2.0, 
            -2.0 * (GLfloat) h / (GLfloat) w, 2.0 * (GLfloat) h / (GLfloat) w, 
    -10.0, 100.0); 
else
    glOrtho(-2.0 * (GLfloat) w / (GLfloat) h, 2.0 * (GLfloat) w / (GLfloat) h, 
    -2.0, 2.0, 
    -10.0, 100.0);

glMatrixMode(GL_MODELVIEW);

Answer 3

Oui,

et vous devez également modifier les paramètres de ciseaux pour avoir une séparation nette entre les deux vues si elles sont dans la même fenêtre.

Answer 4

Exemple minimal runnable

Tout comme href="https://stackoverflow.com/a/1327092/895245"> , mais plus directe et compilable. Sortie:

Code:

#include <stdlib.h>

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

static int width;
static int height;

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

    glViewport(0, 0, width/2, height/2);
    glLoadIdentity();
    gluLookAt(0.0, 0.0, -3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    glutWireTeapot(1);

    glViewport(width/2, 0, width/2, height/2);
    glLoadIdentity();
    gluLookAt(0.0, 0.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    glutWireTeapot(1);

    glViewport(0, height/2, width/2, height/2);
    glLoadIdentity();
    gluLookAt(0.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0);
    glutWireTeapot(1);

    glViewport(width/2, height/2, width/2, height/2);
    glLoadIdentity();
    gluLookAt(0.0, -3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0);
    glutWireTeapot(1);

    glFlush();
}

static void reshape(int w, int h) {
    width = w;
    height = h;
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
    glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(500, 500);
    glutInitWindowPosition(100, 100);
    glutCreateWindow(argv[0]);
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glShadeModel(GL_FLAT);
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutMainLoop();
    return EXIT_SUCCESS;
}

Compiler avec:

gcc -lGL -lGLU -lglut main.c

Testé sur OpenGL 4.5.0 NVIDIA 352,63, Ubuntu 15.10.

TODO: Je pense que dans OpenGL moderne 4 vous devriez juste rendre à des textures, puis placez les textures orthogonalement à l'écran, voir cela comme un point de départ: http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-14-render-to-texture /

Answer 5

GL 4 vous pouvez rendre à plusieurs dans un rendu viewports passe. Voir ARB_viewport_array et des concepts connexes.

Answer 6

Pensez à OpenGL comme rien de plus que des commandes qui vous préparent à la sortie de la fenêtre vous travaillez actuellement.

Il y a deux commandes avec OpenGL que même les tutoriels de NeHe ne vous disent pas l'importance:

wglCreateContext - qui prend un contexte de dispositif de fenêtre DC, peuvent être obtenues à partir de toute fenêtre - que ce soit une commande d'utilisateur, une forme de fenêtres, une fenêtre GL, ou d'une autre fenêtre d'application (comme bloc-notes). Cela crée un contexte de périphérique OpenGL - ils se réfèrent à un contexte de ressources - que vous utilisez plus tard avec ...

wglMakeCurrent - qui prend deux paramètres, le contexte de l'appareil que vous avez affaire à (le paramètre passé dans le contexte de périphérique Windows dans wglCreateContext) - et le contexte des ressources qui retourne.

Tirer parti que ces deux choses - voici mon conseil:

tutoriel de NEHE fournit une solution qui tire parti de la fenêtre existante SEULEMENT et les segments de l'écran pour le dessin. Voici le tutoriel: http://nehe.gamedev.net/tutorial/multiple_viewports/20002/

Tirer parti glViewport vous aurez besoin de re-tirage sur chaque mise à jour.

C'est une méthode.

Mais il y a une autre - moins graphique et processeur méthode intense:

Créer une fenêtre pour chaque vue en tirant parti d'un contrôle utilisateur.

Chaque fenêtre a son propre hWnd.

Obtenez le DC, le processus du wglCreateContext, puis, sur une minuterie (le mien est de 30 images par seconde), si vous détectez changement d'état, puis sélectionnez wglMakeCurrent pour cette vue et redessiner. Sinon, sautez entièrement la section.

Cela permet d'économiser de valeur de puissance de traitement, et réduit également le code d'avoir à gérer les fenêtres et les calculs viewport manuellement.