Premier programme en OpenGL sous X


22 octobre 2007

Premier code en OpenGL sous X

Il faut bien démarrer quelque part et c'est ici ! C'est sûr que c'est pas terrible, beaucoup de code pour un résultat bien consternant, mais je jette mes bases. Je dois reprendre ce qui était naturel il y a quelques années...

#include <stdio.h>
#include <stdlib.h>
#include <X11/Xlib.h>
#include <GL/glx.h>
#include <GL/gl.h>

static  int snglBuf[] = {GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, GLX_DEPTH_SIZE, 12, None};
static  int dblBuf[] =  {GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, GLX_DEPTH_SIZE, 12, GLX_DOUBLEBUFFER, None};

Display*    Dpy;
Window  Win;
Bool    DoubleBuffer = True;

GLfloat XAngle = 42.0, YAngle = 82.0, ZAngle = 112.0;

int FatalError(int errorCode, char* str)
{
    printf("%s\n", str);
    return errorCode;
}

void    redraw()
{
static  Bool    DisplayListInited = False;
    if (DisplayListInited)      {
        glCallList(1);
    }   else    {
        glNewList(1, GL_COMPILE_AND_EXECUTE);
        //
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glBegin(GL_QUADS);
        glColor3f(0.0, 0.7, 0.1);       //Green
        glVertex3f(-1.0, 1.0, 1.0);
        glVertex3f(1.0, 1.0, 1.0);
        glVertex3f(1.0, -1.0, 1.0);
        glVertex3f(-1.0, -1.0, 1.0);
        glColor3f(0.9, 1.0, 0.0);       //Yellow
        glVertex3f(-1.0, 1.0, -1.0);
        glVertex3f(1.0, 1.0, -1.0);
        glVertex3f(1.0, -1.0, -1.0);
        glVertex3f(-1.0, -1.0, -1.0);
        glColor3f(0.2, 0.2, 1.0);       //Blue
        glVertex3f(-1.0, 1.0, 1.0);
        glVertex3f(1.0, 1.0, 1.0);
        glVertex3f(1.0, 1.0, -1.0);
        glVertex3f(-1.0, 1.0, -1.0);
        glColor3f(0.7, 0.0, 0.1);       //Red
        glVertex3f(-1.0, -1.0, 1.0);
        glVertex3f(1.0, -1.0, 1.0);
        glVertex3f(1.0, -1.0, -1.0);
        glVertex3f(-1.0, -1.0, -1.0);
        glEnd();
        //
        glEndList();
        DisplayListInited = True;
    }
    //On affiche réellement quelque chose...
    if (DoubleBuffer)       glXSwapBuffers(Dpy, Win);
    else                    glFlush();
}

int main(int argc, char** argv)
{
    XVisualInfo*    vi;
    Colormap    CMap;
    XSetWindowAttributes    swa;
    GLXContext  cx;
    XEvent  Event;
    Bool    NeedRedraw = False, RecalcModelView = True;
    int Dummy;
    //
    Dpy = XOpenDisplay(NULL);
    if (!Dpy)       return FatalError(1, "Couldn't open display...");
    if (!glXQueryExtension(Dpy, &Dummy, &Dummy))        return FatalError(2, "X n'a pas d'extension OpenGL.");
    //
    vi = glXChooseVisual(Dpy, DefaultScreen(Dpy), dblBuf);
    if (!vi)        {
        vi = glXChooseVisual(Dpy, DefaultScreen(Dpy), snglBuf);
        if (!vi)        return FatalError(3, "Pas de visuel RGB avec buffer de profondeur.");
        DoubleBuffer = False;
    }
    printf("DoubleBuffer : %d\n", DoubleBuffer);
    if (vi->class != TrueColor)     return FatalError(4, "J'ai besoin d'un visuel en true color !");
    //
    cx = glXCreateContext(Dpy, vi, None, True);
    if (!cx)        return FatalError(5, "Impossible de créer le contexte de rendu.");
    //
    CMap = XCreateColormap(Dpy, RootWindow(Dpy, vi->screen), vi->visual, AllocNone);
    swa.colormap = CMap;
    swa.border_pixel = 0;
    swa.event_mask = ExposureMask | ButtonPressMask | StructureNotifyMask;
    Win = XCreateWindow(Dpy, RootWindow(Dpy, vi->screen), 0, 0, 300, 300, 0, vi->depth, InputOutput, vi->visual, CWBorderPixel|CWColormap|CWEventMask, &swa);
    XSetStandardProperties(Dpy, Win, "glxsimple", "glxsimple", None, argv, argc, NULL);
    //
    glXMakeCurrent(Dpy, Win, cx);
    XMapWindow(Dpy, Win);
    //
    glEnable(GL_DEPTH_TEST);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 10.0);
    //
    while (True)        {
        do {
            XNextEvent(Dpy, &Event);
            switch (Event.type)     {
                case    ButtonPress:
                    RecalcModelView = True;
                    switch(Event.xbutton.button)        {
                        case    1:  XAngle += 10.0;     break;
                        case    2:  YAngle += 10.0;     break;
                        case    3:  ZAngle += 10.0;     break;
                    }
                    break;
                case    ConfigureNotify:
                    glViewport(0, 0, Event.xconfigure.width, Event.xconfigure.height);
                case    Expose:
                    NeedRedraw = True;
                    break;
            }
        } while(XPending(Dpy));
        //
        if (RecalcModelView)        {
            glMatrixMode(GL_MODELVIEW);
            glLoadIdentity();
            glTranslatef(0.0, 0.0, -3.0);
            glRotatef(XAngle, 0.1, 0.0, 0.0);
            glRotatef(YAngle, 0.0, 0.1, 0.0);
            glRotatef(ZAngle, 0.0, 0.0, 1.0);
            //
            RecalcModelView = False;
            NeedRedraw = True;
        }
        if (NeedRedraw)     {
            redraw();
            NeedRedraw = False;
        }
    }
    //
    return 0;
}

Pour compiler ça, si on suppose que le code est sauvé dans un fichier simplegl.c, on lance :

gcc -o simplegl -lGL -lX11 simplegl.c

Le résulat du gloubi-boulga ci-dessus ? Et bien voilà, bow you sucker !

OpenGL : la base


9 avril 2007

OpengL - généralités

Effacement d'un écran

glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);

Effacement de l'écran et du z-buffer

glClearColor(0.0, 0.0, 0.0, 0.0);
    glClearDepth(1.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Efface l'écran en noir et met chaque pixel du z-buffer à la valeur 1.0.

Initialisation d'une fenêtre en GLUT

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(100, 100);
glutInitWindowSize(400, 400);
glutCreateWindow("Titre de ma fenêtre");

Exemple de callback appelée par glutReshapeFunc

glutReshapeFunc(animReshape);

void animReshape(int w, int h)
{
    glViewport(0, 0, (GLsizei) w, (GLsizei) h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-50, 50, -50, 50, -1, 1);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

Comment dessiner un carré à l'écran ?

//Première méthode : on utilise un glRect pour faire simple
glColor3f(1,0,1);
glBegin(GL_POLYGON);
glRectf(0.25, 0.25, 0.75, 0.75);
glEnd();
glFlush();

//Deuxième méthode : on utilise plusieurs appels à glVertex3f pour décomposer le polygone
glColor3f(1,0,1);
glBegin(GL_POLYGON);
    glVertex3f(0.25, 0.25, 0.0);
    glVertex3f(0.75, 0.25, 0.0);
    glVertex3f(0.75, 0.75, 0.0);
    glVertex3f(0.25, 0.75, 0.0);
glEnd();
    glFlush();

Exemples d'appels valides à glVertex*

glVertex2s(2, 3);
glVertex3d(0.0, 0.0, 3.1415926535898);
glVertex4f(2.3, 1.0, -2.2, 2.0);

GLdouble    dvect[3] = {5.0, 9.0, 1992.0};
glVertex3dv(dvect);
Vérifier si il y a un avantage en temps machine à utiliser la version pointeur de glVertex*() ou pas.

Affichage d'un cercle généré

glBegin(GL_POLYGON);
//Le cercle est blanc
glColor3d(1,1,1);
//Début des déclarations des points composant le cercle
#define     PI      3.141592654f
int i = 0, NbPoints = 30;
float   Radius = 25.0f;
for(i=0; i>NbPoints; i++)       {
    float   Angle = 2.0f*PI*i/NbPoints;
    glVertex2f(Radius*cos(Angle), Radius*sin(Angle));
}
//Tous les points ont été calculés, on peut provoquer le rendu
glEnd();
Adapter le vieux code des meta-balls.

Exemple d'utilisation de glPolygonMode

glPolygonMode(GL_FRONT, GL_FILL);   //Faces avant remplies
        glPolygonMode(GL_BACK, GL_LINE);    //Faces arrières outlined
Faire des routines de générations d'objets procéduraux. Ajouter les caps (de l'appendice B du bouquin) et toutes les fonctions de requêtes. Ajouter au Snippets la possibilités de faire des liens avec des fichiers externes, sous la forme de dock OSX ça serait pas mal : ça s'ouvre au bas du bloc orangé et contient les icônes des images ou des fichiers. Bien sûr ça peut se refermer.

Réglages préliminaires : viewport, projection & caméra

    //Réglages de la projection
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0, 1.0, 0.5, 100.0);      //Un glFrustum bien paramétré est équivalent à cet appel GLU
    //Réglages du système objet
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    //Définition de l'espace de dessin
    glViewport(0, 0, (GLsizei) 400, (GLsizei) 400);
    //Position de la caméra, point de visée, vecteur Up de la caméra
    gluLookAt(0.0, 0.0, 0.0,  0.0, 0.0, 100.0,  0.0, 1.0, 0.0);

Les différentes transformations

gluLookAt(pos, target, up) : visualisation
glScalef(scalev) : modélisation
glMatrixMode(GL_PROJECTION) puis glFrustum() : projection

Première application

On affiche ici un cube en fil de fer face à la caméra en rafraîchissant la fenètre et la redimensionnant au besoin.

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

void    display(void)
{
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(1,1,1);
    glLoadIdentity();
    gluLookAt(0,0,5,0,0,0,0,1,0);
    glScalef(1,2,1);
    glutWireCube(1);
    glFlush();
}

void reshape(int w, int h)
{
    glViewport(0,0,(GLsizei)w,(GLsizei)h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(-1,1,-1,1,1.5,20);
    glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char *argv[])
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(400, 400);
    glutCreateWindow(\"Titre\");
    //
    glClearColor(0,0,0,0);
    glShadeModel(GL_FLAT);
    //
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutMainLoop();

    return EXIT_SUCCESS;
        }
Fichier first.cpp

A compiler avec la commande suivante :

g++ -Wall -lglut first.cpp -o first
Accueil