1.

Historia

⚫ OpenGL es un estándar sobre gráficos por computadora. Hoy día

es uno de los estándares gráficos más conocido del mundo.
⚫ En 1982 nació en la Universidad de Standford el concepto de
"graphics machine" y éste fue utilizado por Silicon Graphics
Corporation en su propia estación Silicon IRIS para crear un
Introducción a OpenGL

renderizador. Así nació la librería IRIS GL.

⚫ A raíz de esto, en 1992 muchas empresas del hardware y software se
pusieron de acuerdo para desarrollar conjuntamente una librería
gráfica libre: OpenGL.
⚫ Entre estas empresas destacaban Silicon Graphics Inc., Microsoft,
IBM Corporation, Sun Microsystems, Digital Equipment Corporation
(DEC), Hewlett-Packard Corporation, Intel e Intergraph Corporation.
Así nacio OpenGL (Open Graphics Library).
1
 1. Historia

⚫ Fue importante para el despegue definitivo de OpenGL

la elección de John Carmack para realizar el juego
Quake con esta API gráfica, marcando un precedente
innegable, con OpenGL era más sencillo y eficaz la
realización de programas 3D (1996).
⚫ Para elegir entre DirectX (3.0/3.0a) y OpenGL realizó un
pequeño ejemplo de Lens Flare (brillo sobre las lentes),
con OpenGL escribió unas 30 líneas de código mientras
que en DirectX escribió unas 300 líneas de código,
además el efecto era mejor y más rápido en OpenGL
que en DirectX, por tanto su elección fue clara.
2
1. Historia
Efecto de Lens Flare

3
 2. Uso del OpenGL

⚫ DirectX -> Windows

⚫ OpenGL -> Windows, Linux, Mac (unix)
• Drivers optimizado para el hardware
⚫ XBox 360 -> DirectX
⚫ Wii -> OpenGL
⚫ Playstation 3 -> OpenGL
⚫ resto de consolas -> OpenGL
4
 2. Uso del OpenGL

⚫ Portabilidad: Si nos guiamos por la portabilidad,

DirectX difícilmente supere a OpenGL, dada su gran
dependencia con Windows y sus componentes. Fuera
de este sistema operativo, solamente se encuentra
implementada en la consola Xbox. En cambio, OpenGL
es compatible no sólo con Windows, sino que se utiliza
en sistemas Unix, Linux, Mac y hasta en consolas como
PlayStation 3 y Nintendo Wii. En resumen: exceptuando
Windows y Xbox, todos los sistemas que proveen
soporte para aceleración 3D han escogido a OpenGL
para esa tarea. Por algo será, ¿no?.
5
 2. Uso del OpenGL

⚫ Facilidad de uso: En sus comienzos, varios programadores se

agarraban la cabeza cuando tenían que trabajar con DirectX, debido a lo
complejo de su utilización. Con el correr de las versiones, la balanza se
fue equilibrando y, hoy en día, a pesar de que sigue un paradigma
completamente distinto a OpenGL (inspirado en el modelo COM), ya no
es tan complicado de usar. Lenguajes como Visual Basic o Visual Basic
Script son un ejemplo de los que trabajan con este modelo. Por el lado
de OpenGL, al estar basado en el lenguaje de programación C, es
bastante más comprensible y puede ser adaptado a cualquier otro
lenguaje sin demasiadas complicaciones.
La diferencia principal es que DirectX es una API cuya plataforma se
basa en lo que el hardware es capaz de realizar, mientras que OpenGL
es un tanto más independiente. A su vez, de su implementación
depende la administración de los recursos, algo que en DirectX corre
por cuenta de la aplicación. Este detalle permite un desarrollo de
software más sencillo, pero es más propenso a sufrir los tan temidos
errores de programación (mejor conocidos como bugs). 6
 2. Uso del OpenGL

⚫ Performance: El rendimiento del software creado por medio de una

u otra API sigue siendo un parámetro muy debatido. Dado que
DirectX implementa los drivers a nivel del núcleo en el sistema
operativo y de nivel usuario con un runtime provisto por Microsoft,
existe la necesidad de hacer un cambio entre un modo y otro en las
llamadas a la API. Como consecuencia, la CPU utiliza valiosos
microsegundos en completar la operación, quedando inutilizada
para otra tarea. En cambio, OpenGL, a través de una técnica
conocida como marshalling, evita ese inconveniente y obtiene una
valiosa ventaja en la performance final. A partir de Windows Vista,
DirectX podrá sortear esta deficiencia mediante este mismo
procedimiento, ya que los drivers estarán funcionando más a nivel
de usuario que del kernel del sistema operativo.
7
 2. Uso del OpenGL

⚫ Extensibilidad: OpenGL incluye una propiedad que

le posibilita extender sus capacidades a través de un
driver, añadiendo nuevas funcionalidades. Pero esto
puede conducir a generar una gran cantidad de
variantes de la API, provocando cierta confusión entre
los programadores. Por el lado de DirectX, Microsoft
se encarga de mejorarla pero con menos regularidad.
No obstante, desde hace un par de años que las
actualizaciones aparecen cada vez más seguido.
Depende de la empresa conducida por Bill Gates la
incorporación de características en la API que
aprovechen las novedosas funciones de las GPU más
modernas. 8
 2. Uso del OpenGL

⚫ Usuarios: La ventaja en el ámbito profesional está del lado de OpenGL.

Incluso la propia Microsoft admite la superioridad de ésta en estos
campos. De hecho, muchas de las placas profesionales sólo soportan
esta API, lo que es un decir. Los films animados por computadora son
desarrollados en base a OpenGL, dado su carácter de plataforma de
propósitos generales.
La situación cambia cuando lo miramos desde el punto de vista del
mercado de los videojuegos. DirectX no requiere de la implementación
completa que demanda OpenGL para funcionar (incluyo funciones no
soportadas por el hardware), por lo que se torna más sencillo de utilizar.
Para hacerlo simple, podemos decir que Direct3D es un acceso directo
de bajo nivel a los registros disponibles. Además, posee un mecanismo
que determina si una funcionalidad está o no presente en el dispositivo,
evitando la implementación obligatoria y dejando a elección del
diseñador del videojuego su incorporación en el software. Por este
detalle importante es que vemos muchos más juegos de ordenador
programados en DirectX que en OpenGL. 9
 3. Requisitos para programar
con OpenGL

⚫ Windows, Linux, Unix, Mac OS, etc.

⚫ Un compilador de C (C++)
⚫ Las librerías de OpenGL:
• gl.h libería básica
• glu.h librería con utilidades básicas
• glut.h librería con utilidades avanzadas
• (para hacer menús y manejar el API de Windows)

10
 3. Requisitos para programar
con OpenGL

⚫ Para emplear OpenGL con Visual Studio

.NET 2002, necesitamos:
• Instalar el compilador completo (se pueden omitir
los lenguajes Visual Basic y VC#)
• Para emplear la GLUT, necesitamos
• glut.h
• glut.lib, glut32.lib
• glut.dll, glut32.dll

11
 3. Requisitos para programar
con OpenGL

⚫ Direcciones web importantes:

• www.opengl.org
• nehe.gamedev.net
• www.gamedev.net
• glew.sourceforge.net

12
 4. Funcionalidad Extra
Extensiones

⚫ Son muy variadas y de diversa aplicación.

⚫ Desarrolladas por fabricantes de hardware: permiten
utilizar innovaciones introducidas en el hardware
gráfico manteniendo simplicidad de programación de
OpenGL.
⚫ Librería básica de OpenGL casi no varía de una
versión a otra: cambia las extensiones que soporta.
⚫ Tema importante: como incluirlas (existe una librería
llamada glew(http://glew.sourceforge.net/) que facilita
la carga de extensiones
⚫ Dependiendo de la extensión hay que crear nuevas
constantes, definir puteros nuevas funciones ... 13
 OpenGL como máquina de
estados

⚫ OpenGL es un motor gráfico en modo inmediato o interpretado: los

objetos se envían al motor gráfico como órdenes que tienen un efecto
inmediato. No hay una estructura completa de la escena
⚫ Es una máquina de estados: se especifica un estado y todos los objetos
que se creen a partir de ese momento tienen en cuenta ese estado, hasta
que se cambie
⚫ ¿Cómo funciona la máquina de estados?

1. Activar matriz de vista de modelo // La matriz activa es esta

2. Rotar  alrededor de Z // Se acumula la rotación en la matriz
3. Fijar color rojo // Todo lo que se cree será de color rojo
4. Crear vértice 1 // Crear los vértices 1 y 2, en color rojo, y
5. Crear vértice 2 // con la rotación dada
6. Trasladar a (x,y,z) // Se acumula la traslación
7. Crear vértice 3 // Crear vértice 3, rotado, trasladado y rojo
8. Fijar color verde // Ahora todo lo que se cree será verde
9. Crear vértice 4 // Crear vértice 4, rotado, trasladado y verde….
10. Dibujar // Dibujar todos los vértices creados, cada
// uno con su color y transformación
14
 5. Sintaxis de OpenGL

⚫ Funciones con prefijo gl

⚫ Constantes con prefijo GL_
⚫ Algunas funciones con sufijo
• Número y tipo de parámetros
•glColor3f(1.23, 2.12, 4.08);
•glVertex3i(1, 1, 1);

15
 6. Tipos de datos

Sufij Tipos de Datos Definición en Definición en OpenGL

o C
b Entero 8 bits signed char GLbyte
s i Entero 16 bits short int Glshort
Entero 32 bits GLint, GLsizei

f Real 32 bits float GLfloat, GLclampf

d Real 64 bits double GLdouble
ub Entero positivo 8 bits unsigned char GLubyte. GLboolean
us Entero positivo 16 unsigned short GLushort
bits
ui Entero positivo 32 unsigned long GLuint, GLenum,
bits GLbitfield
16
 6. Tipos de Datos

⚫ Son equivalentes:
• glVertex2i(1, 3);
• glVertex2f(1.0, 3.0);
⚫ Son equivalentes:
• glColor3f (1.0, 1.0, 1.0);
• float color_array[] = {1.0, 1.0, 1.0};
• glColor3fv (color_array);
17
 7. Ejemplo de programa OpenGL

main ()
{
AbrirVentana();
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
glBegin(GL_POLYGON); glVertex2f
(-0.5, -0.5);
glVertex2f (-0.5, 0.5);
glVertex2f ( 0.5, 0.5);
glVertex2f ( 0.5, -0.5);
glEnd();
glFlush();
}
18
 8. Primitivas Gráficas

⚫ Se construyen con:
• glBegin(GLenum mode)
• Lista de vértices
• glEnd()
⚫ Algunas estructuras requieren de un
único par glBegin()-glEnd(), y otras
requieren de varios.
⚫ Podemos encontrar 10 tipos de primitivas
en OpenGL
19
 8. Primitivas Gráficas

⚫ Las primitivas gráficas (valores de mode)

son:
⚫ GL_POINTS
⚫ GL_LINES
⚫ GL_LINE_STRIP
⚫ GL_LINE_LOOP
⚫ GL_TRIANGLES
⚫ GL_TRIANGLE_TRIP
⚫ GL_QUADS
⚫ GL_QUAD_STRIP
⚫ GL_POLYGON
20
 8. Primitivas Gráficas
Ejemplos

⚫ glBegin(mode);
• glVertex3f(x0,y0,z0);
• glVertex3f(x1,y1,z1);
• glVertex3f(x2,y2,z2);
• glVertex3f(x3,y3,z3);
⚫ glEnd();

21
 8. Primitivas Gráficas
Puntos

⚫ Modificar el tamaño de los puntos:

glPointSize(GLfloat tamaño)
• Obtener el rango de tamaños válidos
glGetFloatv(GL_POINT_SIZE_RANGE, dimension)
• Obtener granularidad
glGetFloatv(GL_POINT_SIZE_GRANULARITY, &salto)

⚫ Suavizado de puntos
• para activarlo: glEnable(GL_POINT_SMOOTH)
• para desactivarlo: glDisable(GL_POINT_SMOOTH)

22
 8. Primitivas Gráficas
Líneas

⚫ Grosor de la línea
• void glLineWidth(GLfloat width);

⚫ Patrón de línea
• void glLineStipple(GLint factor, GLushort pattern);
• factor: es el número de veces que un bit se repite
• pattern: el patrón de 16 bits a dibujar 0x0F0F
⚫ Es necesario activarlo/desactivarlo
• glEnable(GL_LINE_STIPPLE);
• glDisable(GL_LINE_STIPPLE);

23
 8. Primitivas Gráficas
Líneas

0 0 F F

Binario =
0000 0000 1111 11
11
Patrón de
Línea =

Línea =

Un segmento

24
 8. Primitivas Gráficas
Polígonos

⚫ void glPolygonStipple( const

GLubyte *mask );
• mask es una matriz de 32x32
⚫ void glDrawPixels( GLsizei width,
GLsizei height, GLenum format,
GLenum type, const GLvoid *pixels
);

25
 8. Sistema de coordenadas

⚫ El mundo 3D de OpenGL
es dextrógiro Y
⚫ El observador siempre en
el origen, mirando hacia
el eje Z negativo

Sentido Dextrógiro o positivo

Z
26
 9. Matrices

⚫ En principio tenemos tres grupos de

matrices en OpenGL
•void glMatrixMode( GLenum mode );
⚫ Donde mode toma los valores:
GL_PROJECTION
GL_MODELVIEW (Modelo de Cámara)
GL_TEXTURE

27
 9. Matrices

orden de aplicación de las matrices

orden de especificación de las matrices

Vértice Matriz Vértice Matriz Vértice Transformación Vértice en

original ModelView transformado Projection proyectado Viewport pantalla
x z x ModelView  = x y z x z x Viewport = x y 
y Projection = x y

...
glViewport (x,y,width,height);
...
glMatrixMode (GL_PROJECTION);
glFrustum (left,right,bottom,top,near,far);
...
glMatrixMode (GL_MODELVIEW); glTranslatef
(10, 10, 10);
...

28
 9. Matrices
Proyección

⚫ Para empezar a dibujar en OpenGL tenemos que

especificar:
• Puerto de vista (viewport)
• Volumen de visualización (matriz de proyección)

far
near
(x,y) Y
width
(right,top)

Z
(left,bottom)
X

29
 9. Matrices Proyección

⚫ Matriz de proyección:
• Podemos usar proyección perspectiva:
• void glFrustum( GLdouble left, GLdouble right,
GLdouble bottom, GLdouble top, GLdouble znear,
GLdouble zfar );
• void gluPerspective( GLdouble fovy, GLdouble
aspect, GLdouble zNear, GLdouble zFar );
• o proyección paralela:
• voidglOrtho( GLdouble left, GLdouble right,
GLdouble bottom, GLdouble top, GLdouble zNear,
GLdouble zFar );

30
 9. Matrices
Proyección

⚫ Ejemplo de código para proyección perpectiva:

• glMatrixMode(GL_PROJECTION);
• glLoadIdentity();
• glFrustum(-10, 10, -10, 10, -10, 10);
o
• gluPerpective(45, ancho/alto, 1, 100);

⚫ Ejemplo de código para proyección paralela:

• glMatrixMode(GL_PROJECTION);
• glLoadIdentity();
• glOrtho(-10, 10, -10, 10, -10, 10);
31
 9. Matrices
Proyección

⚫ Se debe combinar con la vista que queremos

establecer:
• void glViewport( GLint x, GLint y, GLsizei
width, GLsizei height );

coordenadas de la ventana de visualización en píxeles

⚫ Para obtener el viewport:
• // 0] es <x>, [1] es <y>, [2] es <ancho>, [3] es <alto>
• GLint viewport[4];
• glGetIntegerv(GL_VIEWPORT, viewport);

32
 9. Matrices
ModelView y Texturas

⚫ Establece las transformaciones que se aplican a cada

objeto:
• glTranslatef(tx, ty, tz);
• glRotatef(angulo, 0.0, 0.0, 1.0); // eje z
• glScale(sx, sy, sz);
⚫ Se emplea la pila de matrices para independizar los
objetos:
• glPushMatrix();
• glPopMatrix();

33
 10. Buffers

⚫ FrameBuffer (doble y triple buffer), almacena

los colores de los píxeles
⚫ Z-Buffer, buffer de profundidades
⚫ Stencil Buffer, para efectos especiales,
máscaras 2D, sombras, reflejos
⚫ Accumulation Buffer, buffer de mezcla, para
múltiples renders o sombras complejas
⚫ Feedback Buffer, buffer de render en memoria

34
 11. Display Lists

⚫ Para optimizar mediante hardware gráfico nuestros

objetos debemos emplear Display Lists:
• void glNewList(GLuint list, GLenum mode);
• mode puede ser: GL_COMPILE o GL_COMPILE_AND_EXECUTE
• void glEndList(void);
⚫ Para eliminar cualquier lista:
• void glDeleteLists(GLuint list, GLsizei range);
⚫ Si existe una Display List:
• GLboolean glIsList( GLuint list );
⚫ Para dibujar una o varias Display List:
• void glCallList( GLuint list );
• void glCallLists( GLsizei n, GLenum type, const GLvoid
*lists );
35
 11. Display Lists
Ejemplo

glNewList(1, GL_COMPILE);
glBegin(GL_QUADS);
glVertex3f(x0,y0,z0);
glVertex3f(x1,y1,z1);
glVertex3f(x2,y2,z2);
glVertex3f(x3,y3,z3);
glEnd();
glEndList();

⚫ Para dibujar este Quad debemos usar:

• glCallList( 1 ); 36
 12. Texturas
Coordenadas

⚫ Para emplear texturas necesitamos emplear

coordenadas de textura en los vértices que creemos
para modelar nuestros objetos:
• void glTexCoord2f( GLfloat s, GLfloat t );
⚫ donde s y t son coordenadas normalizadas de la
textura (0,1)
y
1
(0,0)
(1,1)
Hola

(0,0) 1 x (1,0) 37
 12. Texturas
Creación de una textura

⚫ Para crear las texturas necesitamos:

GLuint texture[1]; // vector para almacenar las texturas

// cargar la textura desde un fichero en TextureImage

glGenTextures(1, &texture[0]); // genera los nombre de texturas

// Crea la textura desde TextureImage glBindTexture(GL_TEXTURE_2D,

texture[0]); // selecciona esta textura glTexImage2D(GL_TEXTURE_2D, 0, 3,
TextureImage[0]->sizeX,
TextureImage[0]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE,
TextureImage[0]->data);
//Filtrado lineal
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

38
 12. Texturas
Uso de las texturas

⚫ Para usar las texturas necesitamos:

// Habilita el uso de texturas
glEnable(GL_TEXTURE_2D);

// Selecciona la textura
glBindTexture(GL_TEXTURE_2D, texture[0]); //activa la textura almacenada en texture[0]
glCallList(id); // id es un enero identificador del objeto a pintar en una Display List

// o en su lugar podemos poner un glBegin()-glEnd()

39
 13. Iluminación

⚫ Para usar las luces necesitamos:

// Habilita el uso de la iluminación
glEnable(GL_LIGHTHING);

// Habilitar las luces

glEnable(GL_LIGHTi); // con 0 ≤ i < GL_MAX_LIGHTS

// y definir correctamente las luces

void glLightf( GLenum light, GLenum pname, GLfloat param ) // o
void glLighti( GLenum light, GLenum pname, GLint param )

Donde pname puede ser:

• GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_POSITION, GL_SPOT_CUTOFF, GL_SPOT_DIRECTION,
GL_SPOT_EXPONENT, GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, and GL_QUADRATIC_ATTENUATION

40
 14. Selección

⚫ Para seleccionar emplearemos la pila de

nombres que tiene OpenGL:

• void glInitNames( void )

• void glPushName( GLuint name )
• void glLoadName( GLuint name )
• GLint glRenderMode( GLenum mode )
admite tres valores GL_RENDER, GL_SELECT, y GL_FEEDBACK

41
 14. Selección

⚫ void gluPickMatrix( GLdouble x, GLdouble

y, GLdouble delX, GLdouble delY, GLint
*viewport )

⚫ Ejemplo la función Pick3d de la clase

TScene

42
 15. Varios

⚫ Usando glEnable, glDisable tenemos:

• GL_CULL_FACE (elimina caras invisibles)
• GL_CLIP_PLANE (plano de recortado)
• void glClipPlane (GLenum plane , const GLdouble *equation )

• GL_NORMALIZE (normaliza las normales)

• GL_BLEND (transparencia)
• void glBlendFunc ( GLenum sfactor , GLenum dfactor );

• GL_DEPTH_TEST (usa o no el z-buffer)

• GL_STENCIL_TEST (usa o no el stencil buffer)

43
 16. Quadrics

⚫ Para crear cuádricas (esferas, discos, etc):

• GLUquadricObj *disco;
• disco = gluNewQuadric();
• gluDisk(disco, 0.2, 1.2, 32, 32);

⚫ Otras cuádricas:
• gluSphere
• gluCilynder
• gluPartialDisk
• gluCone
44
 16. Quadrics
Texturas

⚫ Para activar las coordenadas de textura:

• void gluQuadricTexture (GLUquadric* quad, GLboolean texture);

⚫ Estilo de dibujo:
• void gluQuadricDrawStyle(GLUquadric* quad, GLenum draw);
• Con los valores de GLU_FILL,GLU_LINE, GLU_SILHOUETTE, y GLU_POINT, como valor de
draw

⚫ Estilo de normal:
• void gluQuadricNormals(GLUquadric* quad, GLenum normal);
• Con los valores de GLU_NONE, GLU_FLAT, and GLU_SMOOTH, como valor de normal

45