1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// Por si los necesitamos
#include <stdio.h>
#include <stdlib.h>
 
// glx incluye los ficheros <X11/Xlib.h> y <X11/Xutil.h>
// para las X11.
#include <GL/glx.h>
// Para OpenGL.
#include <GL/gl.h>
// Para la libreria de utilidad glu.
// En caso de no usarla no sria necesario.
#include <GL/glu.h>
// Definiciones de X11.
#include <X11/X.h>
// Para el tema de teclado, definiciones.
#include <X11/keysym.h>
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Variable para indicar al programa
// que se termine.
bool SALIR = false;
 
// Puntero para acceso a la pantalla.
// En realidad es del servidor X
// pero a efectos practicos es nuestra
// pantalla.
Display *Pantalla;
// Identificador de la ventana que
// vamos a crear.
Window IDventana;
// Estructura para las caracteristicas de
// la pantalla
XVisualInfo *visual_info;
// Estructura para atributos de ventana.
XSetWindowAttributes Atri_ventana;
// Identificador del contexto de GLX
GLXContext ContextoGLX;
// Estructura para manejar eventos.
XEvent evento;
 
// Matriz para almacenar el estado de las teclas.
// Los "KeyCodes", los codigos de tecla seran
// el indice.
bool TECLAS[255];

1
2
3
4
5
6
7
8

// Funcion principal en C o C++. Aqui comienza a ejecutar.
int main(int argc, char **argv)
{
// Variable auxiliar para lo que surja.
int aux;
 
// Inicializo la matriz del teclado a false;
for(aux=0;aux<255;aux++) TECLAS[aux]=false;

1
2
3
4
5
6
7
8
9

// Localizo una pantalla que usar. Normalmente, en un PC,
// deberia haber almenos una. Si se llama con NULL
// obtendremos la pantalla por defecto.
Pantalla = XOpenDisplay(NULL);
// Si no se puede, copio el texto del error a la
// salida de error standard y termino el programa.
if (Pantalla == NULL) {
    fprintf(stderr, "No puedo usar ninguna pantalla");
    exit(1); }

1
2
3
4
5
6
7
8

// Comprobamos que se pueda usar las funciones GLX
// en esta pantalla (con su driver). El segundo y
// tercer parametro no los necesitamos asi que no
// usaremos los valores que retornan.
if(!glXQueryExtension(Pantalla, &aux, &aux)) {
    // Si no se puede vamos a error.
    fprintf(stderr, "No puedo usar GLX");
    exit(1); }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// En una matriz de int's definimos las caracteristicas del formato 
// de pixel que queremos. Lo ultimo debe ser "none".  
// Aqui indicamos que: use RGBA para cada pixel, que use 16
// bits para el buffer de profundidad y que use doble buffer.
static int FormatoPixel[]  = 
	{GLX_RGBA, GLX_DEPTH_SIZE, 16, GLX_DOUBLEBUFFER, None};
// Buscamos el formato de pixel con las caracteristicas de arriba
// para la pantalla en que trabajamos y cargamos la informacion
// en una estructura que esta para eso.
visual_info = 
	glXChooseVisual(Pantalla, DefaultScreen(Pantalla), FormatoPixel);
// Si no se pude elegir el formato que queremos vamos a error.
if (visual_info == NULL) {
    fprintf(stderr, "No encuentro Formato de Pixel adecuado");
    exit(1); }

1
2
3
4
5
6
7
8

// Creamos un contexto para OpenGL. Indicamos la pantalla,
// informacion visual, contextos con los que comparte display lists
// (ninguno para nosotros) y si accede directamente al hardware.
ContextoGLX = glXCreateContext(Pantalla, visual_info, None, GL_TRUE);
// Si no se puede crear vamos a error.
if (ContextoGLX == NULL) {
    fprintf(stderr, "No puedo crear el contexto OpenGL");
    exit(1); }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// Damos los valores que queremos a la estructura
// Atri_ventana.
// Indicamos el colormap, la estructura de colores.
// Si no fallara al crear la ventana.
// Lo hacemos en base a visual_info.
Atri_ventana.colormap=XCreateColormap(Pantalla, 
		RootWindow(Pantalla, visual_info->screen),
		 visual_info->visual, AllocNone);
// Indicamos que eventos hay que notificar a esta ventana.
Atri_ventana.event_mask = KeyPressMask | ExposureMask
                 | ButtonPressMask | StructureNotifyMask
                 | KeyReleaseMask | ButtonReleaseMask
                 | EnterWindowMask | LeaveWindowMask;
 
// El tipo de pixel del borde.
Atri_ventana.border_pixel = 0;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// Creamos la ventana.
IDventana = XCreateWindow(
   Pantalla,   // La pantalla
   RootWindow(Pantalla, visual_info->screen),  // La ventana padre
   0, 0,       // Posicion de la ventana
   600, 400,   // Tamaño de la ventana
   0,          // Ancho del borde
   visual_info->depth, // Profundidad respecto a otras ventanas
   InputOutput,    // Tipo de ventana. Debe ser este para poder pintar.
   visual_info->visual,  // Informacion visual
   CWBorderPixel | CWColormap | CWEventMask,    // Valores que pasamos 
						//en Atri_ventana.
   &Atri_ventana);     // Estructura con atributos de la ventana.
 
 
// Ponemos mas propiedades a la ventana como el titulo o el
// icono(ahora ninguno). En nuestro caso solo el titulo.
XSetStandardProperties(Pantalla, IDventana, "USW", "USW", None,
                         argv, argc, NULL);
 
// Asocio la ventana y el contexto GLX
glXMakeCurrent(Pantalla, IDventana, ContextoGLX);
 
// Hago visible la ventana
XMapWindow(Pantalla, IDventana);
 
// Podemos mover la ventana.
XMoveWindow(Pantalla, IDventana, 100,100);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Inicializamos ahora OpenGL de la forma que queramos
// Que haga comprobacion de profundidad
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glClearDepth(1.0);
// Color con que limpia la pantalla cada frame
glClearColor(0.0, 0.0, 0.4, 0.0);
 
// Ponemos la perspectiva
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// Pongo el viewport.
glViewport(0, 0, 600, 400);
// Pongo perspectiva.
gluPerspective(50.0f, (float)600/(float)400, 0.5f, 50.0f);
// Coloco la camara.
gluLookAt(0,0,-4,0,0,0,0,1,0);
glMatrixMode(GL_MODELVIEW);

1
2
3

// Puntero del tipo de los eventos de teclado
// para cuando se necesite.
XKeyEvent *kevento;

1
2
3
4
5
6
7
8
9
10
11
12
13

// Definimos un "Atom", un nombre o indicador para una caracteristica
// o evento de la ventana. Asociamos este Atom al evento de borrado de
// la ventana "WM_DELETE_WINDOW".
Atom CerradoVentana = XInternAtom(Pantalla, "WM_DELETE_WINDOW", true);
// Indicamos a la ventana que queremos controlar el evento de borrado
// pasandole el Atom.
// Mas tarde, cuando comprobemos los eventos tendremos que
// comprobar el evento "ClientMessage" para ver si se ha producido
// el cierre de la ventana (u otro que hubieramos definido igual).
// Por su parte, la ventana, en vez de cerrarse, lo que hara sera
// notificar el evento, no se borrara. El borrado o lo que creamos
// conveniente, lo haremos nosotros.
XSetWMProtocols(Pantalla, IDventana, &CerradoVentana, 1);

1
2
3
4
5

// Entramos en el bucle del programa.
// Se repite continuamente mientras la
// variable SALIR no sea true.
while (!SALIR)
{

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

// Bucle que se repetira hasta haber
// tratado todos los mensajes.
do
{
  // Obtengo el siguiente mensaje y lo
  // pongo en "evento".
  XNextEvent(Pantalla, &evento);
  // Trato el evento segun el tipo
  switch (evento.type)
  {
     // Si el menseje es producido desde un Atom que hayamos
     // indicado a la ventana.
     case ClientMessage:
        // Comprobamos que efectivamente el mensaje llega
        // por el cierre de la ventana. En realidad solo
        // hemos definido este y solo llegara este.
        if(evento.xclient.data.l[0] == CerradoVentana )
          // Ponemos a true el indicador de fin
          // de programa.
          SALIR=true;
          break;
     // Si es la presion de una tecla.
     case KeyPress:
          // Uso el puntero kevento para
          // acceder a los datos especiales
          // del evento de teclado.
          kevento = (XKeyEvent *) &evento;
          // Uso el keycode como indice de la
          // matriz del teclado.
          TECLAS[kevento->keycode]=true;
          break;
     // Si se suelta una tecla.
     case KeyRelease:
         // Lo mismo que en keypress pero con false
         kevento = (XKeyEvent *) &evento;
         TECLAS[kevento->keycode]=false;
         break;
     // Si es la presion de un boton del raton.
     case ButtonPress:
         //... por ahora no lo usamos
 
         break;
     // Si se suelta un boton del raton.
     case ButtonRelease:
         //... por ahora no lo usamos
 
         break;
     // Si se ha reconfigurado la ventana,
     // cambio de tamaño por ejemplo.
     case ConfigureNotify:
         // Ajusto el viewport al nuevo tamaño.
         glViewport(0, 0, evento.xconfigure.width,
         evento.xconfigure.height);
         // Ajusto la perspectiva y la camara
         glMatrixMode(GL_PROJECTION);
         glLoadIdentity();
         gluPerspective(50.0f,
           (float)evento.xconfigure.width/(float)evento.xconfigure.height,
            0.5f, 50.0f);
         gluLookAt(0,0,-4,0,0,0,0,1,0);
         glMatrixMode(GL_MODELVIEW);
         break;
     // Se debe redibujar el contenido de la ventana,
     // antes estaba oculta por ejemplo.
     case Expose:
         //... por ahora no lo usamos
 
         break;
     // Si el raton entra en la ventana
     case EnterNotify:
         //... por ahora no lo usamos
 
         break;
     // Si el raton abandona la ventana
     case LeaveNotify:
         //... por ahora no lo usamos
 
         break;
     }
 
// Mientras haya mensajes pendientes
// sigo con el bucle.
} while(XPending(Pantalla));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// Aqui pintare la escena y la movere
 
// Limpio el buffer (back buffer) para pintar cosas
// nuevas
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
// Compruebo si se ha pulsado la tecla ESCape.
// Si es que si pongo SALIR a true y el programa terminara.
// Uso usa funcion para convertir el codigo en que pongo
// la tecla a el keycode que uso de indice.
if( TECLAS[XKeysymToKeycode(Pantalla,XK_Escape)] ) SALIR=true;
 
// Pongo color
glColor3f(1,0,0);
// Cargo identidad
glLoadIdentity();
 
// Pinto una esfera con GLU.
GLUquadricObj *q;
q=gluNewQuadric();
gluQuadricDrawStyle(q, GLU_FILL);
gluQuadricNormals(q, GLU_SMOOTH);
gluQuadricTexture(q, GL_FALSE);
gluSphere(q,1,16,16);
gluDeleteQuadric(q);
 
// Cambio los back y front buffer's de forma
// que lo que he pintado se vea.
glXSwapBuffers(Pantalla, IDventana);
 
} // Fin del bucle principal.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Si se termina el bucle principal termina
// el programa.
 
// Desasocio el contexto
glXMakeCurrent(Pantalla, None, NULL);
// Destruyo el contexto.
glXDestroyContext(Pantalla, ContextoGLX);
// Destruyo la ventana
XDestroyWindow(Pantalla, IDventana);
// Cierro la pantalla, la conexion con
// el servidor X.
XCloseDisplay(Pantalla);
 
// Termino el programa retornando 0,
// que termina bien.
return 0;
 
} // Fin de main(..)