No sé para qué me gasto el dinero, pero me alegro de que Nvidia esté “liberando” los gpu gems.

No están todos, cada semana tres capítulos nuevos, así nadie se atraganta

Relacionadas: gpu gems online

Las Breakpoint’s siempre dejan demos espectaculares pero, personalmente, lo que más me fascina de la party son la calidad de algunos de sus seminarios. Se molestan en organizarlos, grabarlos y dejarlos online para disfrute de todo el mundo.

A mi me han gustado especialmente, sin ningún orden específico:
(más…)

Nvidia ha dejado disponible online la primera entrega del GPU gems.Un gesto nada despreciable teniendo en cuenta lo caros que llegan a ser este tipo de libros.

La serie GPU gems se compone de artículos independientes que analizan problemas muy particulares. Son amenos de leer y no se centran únicamente en los gráficos, también exploran otros usos de la GPU o cuestiones de diseño muy prácticas para los programadores que estén trasteando con motores de render .

En esta entrega encontraremos:

• Efectos naturales
• Iluminación y sombras
• Materiales
• Procesado de Imágenes
• Rendimiento y Diseño
• Cálculo general en la GPU

Mañana me toca presentar en una horita GLSL para una asignatura del master. Todo aquel que lo desee está invitado a venir a las 9:00 ( sí, a esa hora las calles ya están puestas ) en el seminario 2S02 del DSIC. A las 12:00 tendremos luego una sesión práctica, a la que quien quiera, también puede venir.

Mientras tanto… voy a acabar la presentación

Update: Aquí está la presentación por si a alguien le sirve de algo:

Recientemente ha aparecido una nueva sección en la página de OpengL OpenGL/SDK. Sin duda la parte más interesante son las páginas de referencia de las funciones de openGL, “OpenGL 2.1 Reference Pages“, aunque no están para descargar siempre se puede tirar de wget para crearnos una copia local, concretamente la linea mágica es:

wget -p -nH -k -np -r -Popengl2 --cut-dirs=3 --html-extension http://www.opengl.org/sdk/docs/man/


Aunque aun faltarán tres documentos que wget no descubre que hace falta bajar

cd opengl2/xhtml
wget http://www.opengl.org/sdk/docs/man/xhtml/pmathml.xsl
wget http://www.opengl.org/sdk/docs/man/xhtml/ctop.xsl
wget http://www.opengl.org/sdk/docs/man/xhtml/mathml.xsl


PD: También podría dejar colgado un tgz con todo, pero no estoy seguro de si es legal o no, de esta forma cada uno se lo hace por su cuenta y riesgo. Realmente lo interesante es que quien no haya usado wget para hacer un mirror de una página por lo menos ya sabe que se puede.

Cargar texturas en OpenGL implica leer una textura, crear un objeto de textura y subir los texels a la gráfica. Los dos últimos pasos, el de crear y subir la información, no son complicados o por lo menos siempre se hacen igual, pero leer una imagen de disco suele ser un quebradero de cabeza si pretendemos hacerlo a mano. Claro está, no me refiero a leer de disco a secas, me refiero a leer imágenes con formato ya sea jpg, png, svg, etc.

Típicamente en el mundillo de los gráficos desde tiempos inmemoriales se ha venido usando un set de librerías conocido por DevIL ( que inicialmente se llamaba OpenIL aunque por problemas con SGI cambiaron el nombre). Esta librería es además de práctica muy sencilla de utilizar y entona muy bien con openGL por estar basada en una máquina de estados y estar separada en varios niveles de abstracción IL, ILU, ILUT (como GL, GLU, y GLUT).

Pero si queremos usar algo más potente de DevIL podemos usar ImageMagick. Con ImageMagick ganaremos no sólo un cargador, además ganamos un editor, compositor y conversor de imágenes con la ventaja de que ImageMagick probablemente ya viene instalada en las ubuntu/debian/*nix normales ( y si no viene, sólo hay que enseñar a usar convert o cualquiera de las command-line-tools de ImageMagick ).

Veamos un breve, rapidísimo tutorial de cómo cargar una imagen con Imagemagick. Vamos a usar la interfaz “C” de magick-wand, también existe una para C++ (así como para python, perl, php,…) pero implicaría tener que añadir una dependencia extra… y la verdad es que Magick-Wand es suficientemente fácil de usar por sí misma.


#include <wand/magick_wand.h>
int main(…) {
MagickWandGenesis();
MagickWand *wand = NewMagickWand();
// …
wand = DestroyMagickWand(wand);
MagickWandTerminus();
}


Las llamadas MagickWandGenesis y MagickWandTerminus inicializan y finalizan la librería, una vez hecho con NewMagickWand y DestroyMagickWand podemos crear y liberar varitas (mágicas) para trabajar con imágenes, transformalas, etc… Lo siguiente consiste en cargar la imagen de un fichero o un BLOB de memoria:


// opcion 1: leer de fichero dado un path
MagickBooleanType status = MagickReadImage ( wand, path );
// opcion 2: leer de un puntero a memoria (data) de tamaño conocido (size)
MagickBooleanType status = MagickReadImageBlob( wand, data, size );
if ( status != MagickFalse )
{
}


Las dos llamadas de MagickReadImage[Blob] hacen lo mismo, leen una imagen y además lo hacen identificando el tipo de imagen que es. Esto lo digo concretamente por la versión “blob”, no hay que decirle si es un png, jpg, ppm, svg… Imagemagick lo identificará por la cabecera del fichero, si usáis vuestro propio cargador de ficheros no tenéis más que leer el fichero entero sin preocuparos del tipo de fichero y MagickReadImageBlob intentará leerlo.
También existe la versión MagickReadImageFile que recibe un descriptor de fichero tipo FILE*
nota: en vuestro caso particular sólo hay que usar una de las dos opciones, claro está

El resultado es un booleano, si todo a ido bien sólo queda recuperar esa información y subirlo a la textura. En este caso vamos a tener en cuenta si la imagen tiene alfa o no (para ImageMagick es ver si tiene opacidad):


unsigned long width = MagickGetImageWidth( wand );
unsigned long height = MagickGetImageHeight( wand );
unsigned char *data = 0;
MagickFlipImage( wand );
// reservamos para una textura y la activamos
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
if ( MagickGetImageChannelDepth(wand, OpacityChannel) > 1 )
{
// con alfa
data = new unsigned char[width*height*4];
MagickGetImagePixels(wand, 0,0, width, height, "RGBA", CharPixel, data);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
}
else
{
// sin alfa
data = new unsigned char[width*height*3];
MagickGetImagePixels(wand, 0,0, width, height, "RGB", CharPixel, data);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
}
delete[] data;


Este ya es un buen cacho, primero obtenemos ancho y alto de la imagen, hacemos un flip de la imagen (ya que en OpenGL las imágenes empiezan abajo a la izquierda - pitfall 12) y reservamos una textura de OpenGL. Después preguntamos a la varita si la imagen tiene alfa, en realidad le preguntamos si la profundidad del canal de opacidad es mayor que 1, si es así reservamos espacio para guardarnos la información de la imagen en formato RGBA y lo subimos a la textura. Si no tiene alfa pues lo mismo pero en formato RGB. Y como somos muy limpios, al final un delete[] para liberar la memoria temporal donde guardamos la imagen.

Y finalmente el ejemplo más o menos completo del tema… Para compilarlo en linux no hay que olvidar que tenemos un mágico `Wand-config --cppflags --cflags --ldflags --libs` para ayudarnos.


#include <GL/gl.h>
#include<wand/magick_wand.h>
int main(…) {
// inicializamos openGL o lo que haga falta…
GLuint texture = 0; // nuestra textura
MagickWandGenesis();
MagickWand *wand = NewMagickWand();
// opcion 1: leer de fichero dado un path
MagickBooleanType status = MagickReadImage ( wand, path );
// opcion 2: leer de un puntero a memoria (data) de tamaño conocido (size)
MagickBooleanType status = MagickReadImageBlob( wand, data, size );
if ( status != MagickFalse )
{
unsigned long width = MagickGetImageWidth( wand );
unsigned long height = MagickGetImageHeight( wand );
unsigned char *data = 0;
MagickFlipImage( wand );
// reservamos para una textura y la activamos
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
if ( MagickGetImageChannelDepth(wand, OpacityChannel) > 1 )
{
// con alfa
data = new unsigned char[width*height*4];
MagickGetImagePixels(wand, 0,0, width, height, "RGBA", CharPixel, data);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
}
else
{
// sin alfa
data = new unsigned char[width*height*3];
MagickGetImagePixels(wand, 0,0, width, height, "RGB", CharPixel, data);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
}
delete[] data;
}
wand = DestroyMagickWand(wand);
MagickWandTerminus();
}


Glee es una pequeña librería multiplataforma + cabecera (gl.h) que permite programar siempre con la última versión de la especificación de OpenGL, en este caso la versión 2.1.

Glee cargará por ti dinámicamente aquellas extensiones que soporte tu tarjeta, sólo hay que tener en cuenta que aunque estés progrmando contra el API de OpenGL 2.1, es posible que tu tarjeta NO soporte ciertas llamadas, o ciertos formatos… las comprobaciones de las capabilities de la tarjeta se tienen que seguir haciendo ( en tiempo de ejecución ).

En resumen, el que prueba esta librería no vuelve a complicarse la vida con las extesiones de OpenGL.

Desde: OpenGL.org

Que un programa escrito en OpenGL hace diez años compile hoy día puede decir dos cosas: o bien que OpenGL es fenomenal y su diseño ha permitido crecer de forma monótona (siempre incrementando su api y nunca dejando algo deprecated) sin consecuencias o por el contrario OpenGL es compatible hacia atrás pero usar un estilo de programación de hace diez años tiene consecuencias.

La respuesta es: tiene consecuencias (y graves). ¿Cómo hacer que OpenGL vaya mucho más deprisa? para averiguarlo podéis ver este video de la última Blender Conference. Este video nos viene a contar desde qué punto de vista hemos de enfocar el uso de OpenGL hoy día, ya que el hecho de poder programar como hace 10 años no justifica el hacerlo teniendo en cuenta la penalización que eso supone.

Me ha gustado tanto que intentaré desglosar su contenido en pequeños posts, por si alguien tiene dificultades con el inglés.
Noticia original OpenGL performance programming.