Shakaran

Daftone WebGL + Music website

Normalmente habrás notado que en GNU/Linux el soporte de ATI todavía no es muy bueno. Existen varios problemas para el renderizado 3D. Como consecuencia origina que en navegadores que proporcionan WebGL para renderizar páginas en 3D haya numerosos fallos o incluso este deshabilitado su soporte. Cuando el soporte esta deshabilitado o marcado como experimental los desarrolladores introducen esas tarjetas gráficas en una listas negras (blacklist) a la espera de que en un futuro exista mejor soporte.

Esto hace que no se pueda disfrutar de la experiencia completa de la web con aplicaciones 3D en WebGL. Sin embargo, es posible ignorar estas configuraciones y listas negras y obligar al navegador a que renderice esas páginas. La desventaja es que posibiemente si la aplicación es compleja tengamos muchos fallos o vaya lenta, aún así es mejor que no disponer de ella.

En Ubuntu para Google Chrome sólo es necesario iniciar la aplicación (desde su binario correspondiente) con algunas opciones como parámetro:

1

/opt/google/chrome/google-chrome --enable-webgl --allow-file-access-from-files --ignore-gpu-blacklist %U

Esto habilita WebGL, permite el acceso a archivos e ignora la lista negra. Se puede crear un alias con estos parámetros o incluso un lanzador configurado con ese comando en sus propiedades.

Por ejemplo:

Propiedades del Lanzador Google Chrome

Para comprobar el soporte se puede escribir en una pestaña del navegador:

1

about:gpu

Si la mayoria de características es verde, entonces probablemente podamos ejecutar aplicaciones en WebGL. En mi caso:

Soporte de características para WebGL

Por ejemplo, si quieres probarlo con alguna web muy visual. Puedes cargar la web de DafTunes que es una web donde se combina el 3D de WebGL con la música al estilo de la conocida canción Harder Better Faster Stronger de DaftBodies

Y si estás participativo, observa los mensajes de error en tu consola y contribuye reportando fallos a Chrome o el proyecto Mesa para que en próximas versiones exista mejor soporte.

ATI? Piensatelo dos veces

El soporte de ATI en GNU/Linux que ofrece deja mucho que desear en los controladores oficiales y propietarios. Son frecuentes los fallos en aplicaciones que hacen un uso normal de la tarjeta gráfica y con las ultimas incorporaciones de Compiz y Unity al escritorio de Ubuntu, la aceleración es muy lenta para un uso regular. A fecha de hoy, los controladores libres de MESA, en su última versión (9.0), tampoco ofrecen muchas de las funcionalidades básicas o incluso no disponen del soporte de OpenGL 2.1 (lanzado en 2006) en la mayoría de las tarjetas gráficas.

No hablemos de OpenGL 3.0 o superior a menos que dispongas de tarjeta gráfica Intel o Nvidia (con controladores propietarios también). Aunque MESA tiene bastante actividad, prácticamente cada día hay nuevo código desarrollado, tiene un desarrallo demasiado lento para adaptarse rápido al mercado del escritorio o incluso de juegos (aunque parece que pueden existir avances en los próximos meses).

Resumiendo aunque puede que inicialmente te haya ido bien con los controladores propietarios de ATI, quizás tengas mejor soporte al usar los controladores libres y te ofrezcan algo más de estabilidad y funcionalidades. Por otro lado, usando los controladores libres es más posible que tus fallos se corrijan pronto, ya que se lanzan versiones más rapidamente en cada nueva versión de Ubuntu que las que ofrece ATI. También estarías favoreciendo la alternativa que esta basada en software libre.

Por ello, para desinstalar los controladores propietarios de ATI, ejecuta los siguientes comandos:

1
2
3
4

sudo apt-get purge xorg-driver-fglrx fglrx-*
sudo apt-get install --reinstall libgl1-mesa-glx libgl1-mesa-dri
sudo dpkg-reconfigure xserver-xorg
sudo apt-get install --reinstall xserver-xorg-core

Después reinicia tu ordenador y ya estarás usando los controladores libres. Puedes comprobarlo con el comando:

1

glxinfo | grep Mesa

OpenGL es un librería de gráficos bastante versátil. En este artículo vamos a ver un pequeño ejemplo de su potencial.

El ejemplo consiste en dibujar un triángulo blanco en una ventana y que al pulsar la tecla ‘c’ nuestro triángulo se coloree de rojo, verde y blanco en cada vértice. Por otro lado si pulsamos la tecla escape ‘Esc’ la aplicación terminará. Además añadiremos un pequeño menú que se accionara al pulsar el botón derecho del ratón, donde tendremos la opción de cambiar de modo y salir.

Una pequeña imagen que detalla el proceso:

Ejemplo sencillo con OpenGL

A continuación pongo el código y más adelante lo detallo paso a paso:

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

#include < stdio.h >;
#include < stdlib.h >;
#include < GL/glut.h >;
 
enum {
  MENU_CHANGE = 1,
  MENU_EXIT
};
 
static int mode = 0;
 
void SelectFromMenu(int idCommand)
{  
    switch (idCommand)
    {
        case MENU_CHANGE:
            mode = (mode == 0) ? 1: 0;
            glutPostRedisplay();
            break;
 
        case MENU_EXIT:
            exit(0);
            break;
    }
    glutPostRedisplay();
}
 
void Keyboard(unsigned char key, int x, int y)
{
    switch (key)
    {
        case 27: // ESCAPE key
            exit(0);
            break;
 
        case 'c':
            SelectFromMenu(MENU_CHANGE);
            break;
    }
}
 
int buildPopupMenu(void)
{
    int menu = glutCreateMenu(SelectFromMenu);
    glutAddMenuEntry("Cambiar modo\tc", MENU_CHANGE);
    glutAddMenuEntry("Salir\tEsc", MENU_EXIT);
 
    return menu;
}
 
void display ()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    glTranslatef(0.0, 0.0, -4.0); 
 
    if(mode == 0)
    {
        glBegin(GL_TRIANGLES);
 
            glColor3f (1.f, 1.f, 1.f);    // White colour
            glVertex3f(0.0, 1.0, 0.0);
            glVertex3f(-1.0, -1.0, 0.0);
            glVertex3f(1.0, -1.0, 0.0);
 
        glEnd();
    }
    else
    {
        glBegin(GL_TRIANGLES);
 
            glColor3f (0.f, 1.f, 0.f);    // Green colour
            glVertex3f(0.0, 1.0, 0.0);
 
            glColor3f (1.f, 1.f, 1.f);    // White colour
            glVertex3f(-1.0, -1.0, 0.0);
 
            glColor3f (1.f, 0.f, 0.f);    // Red colour
            glVertex3f(1.0, -1.0, 0.0);
 
        glEnd();
    }
 
    glutSwapBuffers();
}
 
void resize (int w, int h)
{
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(50., w/(double)h, 1., 10.);
    glMatrixMode(GL_MODELVIEW);
}
 
void init (void)
{
    glEnable(GL_DEPTH_TEST);
}
 
int main(int argc, char *argv[])
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(400, 400);
    glutInitWindowPosition(200, 200);
    glutCreateWindow("Ejercicio");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(resize);
    glutKeyboardFunc(Keyboard);
 
    buildPopupMenu();
    glutAttachMenu(GLUT_RIGHT_BUTTON);
 
    glutMainLoop();
 
    return 0;
}

El funcionamiento principal, es tener una función display(), que según en el modo que estemos, dibujara una u otra figura (coloreada de una manera u otra). Para ello utilizaremos una variable global estática con la que guardaremos el modo en el que estamos, cuando se requiera redibujar, miraremos el modo y lo cambiaremos y dibujaremos la nueva figura. Las funcion de keyboard() llamará al menu según la tecla (salir o cambiar modo) y el menú se encargara de llamar a display y cambiar el modo.

De forma más detalla en la funcion main() primero pasamos los argumentos de entrada con glutInit() y inicializamos glutInitDisplaymode con un doble buffer y RGB, ya que necesitaremos un buffer doble para que nuestras figuras se rendericen en un frame y mientras en otro se procesen.

Le damos un tamaño a la ventana de 400×400 con glutInitWindowSize() y en la posición 200×200 con un título de ventana “Ejercicio”. y llamamos a la función init para que active la prueba de profundidad.

Luego asignamos una funcion de retrollamada (callback) para mostrar nuestra ventana con lgutDiplayFunc(), la función de retrollamada sera display(), que la veremos más adelante.

Otra función de retrollamada para cuando redimensionemos la ventana y despues llamaremos a buildPopupMenu() que sera una función para construir nuestro menú.

Y adjuntaremos el menú cuando se presione el botón derecho del ratón con glutAttachmenu(). Despues llamamos al bucle principal de glut.

Nota: algo importante a resaltar, si utilizas una tarjeta gráfica ATI, es posible que tengas algun fallo si pones la línea, ya que el buffer no quedara totalmente limpio al dibujar en pantalla:

1

 glClear(GL_COLOR_BUFFER_BIT);

Por eso es mejor ponerlo así y evitamos este tipo de fallos (desconozco si en otras tarjetas se da dicho fallo):

1

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

Para compilar:

gcc -lGL -lGLU -lglut ejercicio.c -o ejercicio

Y ejecutarlo:

./ejercicio

¿Te ha gustado o resultado útil? Pues deja un comentario con tu opinión