opengl.introduccion
TRANSCRIPT
Introducció
n a O
penG
L
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
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
3. Requisitos para programar
con OpenGL
Direcciones web importantes:
• www.opengl.org
• nehe.gamedev.net
• www.gamedev.net
• glew.sourceforge.net
12
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
14
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
6. Tipos de datos
16
Sufijo Tipos de Datos Definición en C Definición en OpenGL
b Entero 8 bits signed char GLbyte
s
i
Entero 16 bits
Entero 32 bits
short
int
Glshort
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 bits unsigned short GLushort
ui Entero positivo 32 bits unsigned long GLuint, GLenum,
GLbitfield
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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 OpenGL19
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
8. Primitivas Gráficas
Puntos
Modificar el tamaño de los puntos:glPointSize(GLfloat tamaño)
• Obtener el rango de tamaños válidosglGetFloatv(GL_POINT_SIZE_RANGE, dimension)
• Obtener granularidadglGetFloatv(GL_POINT_SIZE_GRANULARITY, &salto)
Suavizado de puntos• para activarlo: glEnable(GL_POINT_SMOOTH)
• para desactivarlo: glDisable(GL_POINT_SMOOTH)
22
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
8. Primitivas Gráficas
Líneas
24
Binario =
Patrón de
Línea =
Línea =
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 F F
Un segmento
Introducció
n a O
penG
L
8. Primitivas Gráficas
Polígonos
25
void glPolygonStipple( const
GLubyte *mask );
• mask es una matriz de 32x32
void glDrawPixels( GLsizei width,
GLsizei height, GLenum format,
GLenum type, const GLvoid *pixels
);
Introducció
n a O
penG
L
8. Sistema de coordenadas
26
X
Y
Z
Sentido Dextrógiro o positivo
El mundo 3D de OpenGL
es dextrógiro
El observador siempre en
el origen, mirando hacia
el eje Z negativo
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
28
ModelView Projection zyx x = zyx x zyx= yx
Vértice
original
Matriz
ModelView
Vértice
transformado
Matriz
Projection
Vértice
proyectado
Transformación
Viewport
Vértice en
pantalla
x =
orden de aplicación de las matrices
orden de especificación de las matrices
...
glViewport (x,y,width,height);
...
glMatrixMode (GL_PROJECTION);
glFrustum (left,right,bottom,top,near,far);
...
glMatrixMode (GL_MODELVIEW);
glTranslatef (10, 10, 10);
...
Viewport
9. Matrices
Introducció
n a O
penG
L
29
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)
near
X
Z
Y
far
(left,bottom)
(right,top)
(x,y)width
Introducció
n a O
penG
L
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:•void glOrtho( GLdouble left, GLdouble right,
GLdouble bottom, GLdouble top, GLdouble zNear,
GLdouble zFar );
30
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
37
(0,0) x
y
1
1(0,0)
(0,1)
(1,1)
(1,0)
Hola
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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
Introducció
n a O
penG
L
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