máster en creación y producción de videojuegos opengl gonzalo mariscal vivas gonzalo/opengl

Máster en Creación y Producción de Videojuegos

OpenGL

Gonzalo Mariscal Vivashttp://www.esi.uem.es/~gonzalo/opengl

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid 2

OpenGL - Índice

1. Introducción

2. Operaciones OpenGL

3. Rasterización / Renderizado

4. Per-Fragment Operations and the Framebuffer

5. Special Functions

6. State and State Requests


• Definiciones

– OpenGL (del inglés “Open Graphics Library”) es una interfaz software para el hardware orientado a gráficos[The OpenGL Graphics System: A Specification]

– OpenGL es una especificación de una librería gráfica de bajo nivel[Terry OpenGL linux Tutorial]

1. Introducción


1. Introducción

• Características OpenGL– Aceleración hardware 3D rápida y completa– Efectos 3D en tiempo real

• niebla• anti-aliasing (evita "efecto de sierra" o aliasing)• sombras volumétricas• bump mapping (detalle de imagen)• motion blur (efecto de movimiento)• Transparencias• Reflexiones• texturas 3D• ...

– Innovaciones en software y hardware • Extensiones de OpenGL


1. Introducción

• Características OpenGL (continuación)– Multiplataforma

• Windows• MacOS• Linux/UNIX• Dispositivos móviles• Estaciones de juegos• Simuladores de vuelo• ...

– Estable• Primeras versiones desde 1992

– High End 3D workstation y supercomputadoras


2. Operaciones OpenGL2.1. Fundamentos de OpenGL

• OpenGL está concebido para renderizar sobre un framebuffer– Framebuffer: Zona de memoria especial de lectura / escritura

donde se representan todos y cada uno de los píxeles de las imágenes desplegadas en un dispositivo de vídeo.

OpenGL Framebuffer

Sistema Operativo Usuario


2.1. Fundamentos de OpenGL

• Órdenes (procedimientos o funciones) para la especificación de objetos geométricos en 2D ó 3D:1. Primitivas básicas de formas geométricas.

• Primitivas se definen como un grupo de figuras geométricas formadas por uno o más vértices.

• Primitivas básicas de OpenGL:– Puntos– Líneas– Polígonos– Imágenes– Bitmaps


2.1. Fundamentos de OpenGL

2. Operaciones gráficas fundamentales 2D y 3D incluyendo especificación de parámetros:– como matrices de transformación, – coeficientes de luces, – métodos antialiasing, y – operadores de actualización de píxeles.

3. Órdenes para render de objetos dentro del framebuffer

Rénderizar = Rasterizar = Representar

Estas órdenes gestionan cómo los objetos son renderizados (3D => 2D)


2.2. Sintaxis de las órdenes GL

• Nomenclatura:– Órdenes comienzan por “gl”– Constantes comienzan por “GL_”– Tipos comienzan por “GL”



• Órdenes incluyen tipos de parámetros:

void Vertex3f( float x, float y, float z );

void Vertex2sv( short v[2] );

• En general:

rtype Name{_1234}{_ b s i f d ub us ui}{_v}

( [args ,] T arg1 , . . . , T argN [, args] );

“_” indica que no hay ningún carácter

“letras” indican tipos GL



• Las letras definen tipos GL:



• Descripción de tipos GL:


2.3. Operaciones GL básicas

• Pipeline del proceso de órdenes:


2.4. Errores GL

• enum GetError( void );– Resumen de Errores:


2.5. Paradigma Begin / End

• void Begin( enum mode );• void End( void );


2.5.1. Begin / End

• Points– Define un Vértice– mode= POINTS

• Line Strips– Serie de líneas conectadas entre sí. – Se definen Vértices– mode= LINE STRIP.

• Line Loops.– Serie de líneas conectadas entre sí. – Se definen Vértices. – El último vértice se conecta con el primeo– mode= LINE_LOOPS


2.5.1. Begin / End

• Separate Lines.– Líneas separadas– Se definen Pares de Vértices (inicio y fin de línea)– mode= LINES.

• Polygons.– Se define la frontera igual que Line Loops.– mode= POLYGON.

• Triangle Strips.– Se definen vértices y se van formando triángulos

adyacentes.– Cada vértice se une a los dos anteriores para formar el

triángulo.– mode= TRIANGLE STRIP.


2.5.1. Begin / End

• Triangle Fan.– Se definen vértices y se van formando triángulos

adyacentes.– Todos los triángulos comparten el vértice inicial.– mode= TRIANGLE FAN.

• Separate Triangles.– Se definen los triángulos agrupando vértices de

tres en tres.– mode= TRIANGLES.


2.5.1. Begin / End


2.5.1. Begin / End

• Quadrilateral (quad) strips– Se construyen los cuadrados compartiendo dos

vértices con el anterior– mode=QUAD_STRIP

• Separate quads– Se agrupan los vértices de cuatro en cuatro– mode=QUADS


2.5.1. Begin / End

• Quadrilaterals


2.5.2 Polygon Edges

• Etiquetar bordes:– void EdgeFlag( boolean flag );– void EdgeFlagv( boolean *flag );

• Se usa para POLYGON, TRIANGLES, o QUADS– Si el flag de arista está activado a TRUE, cada

vértice definido comienza una arista etiquetada como “borde”

– Si el flag de arista está desactivado a FALSE, las aristas definidas están etiquetadas como “no borde”


2.5.3 Órdenes GL entre pares Begin/End

• Órdenes que especifican coordenadas de vértices– Vertex

• Colores de vértices– Color– SecondaryColor– Index

• Coordenadas normales– Normal

• Coordenadas de textura – TexCoord– MultiTexCoord

• Atributos genéricos de vértices– VertexAttrib



• Coordenadas de niebla– FogCoord

• Vector de Elementos– ArrayElement

• Órdenes EvalCoord y EvalPoint• Órdenes para especificar parámetros iluminación de

materiales:– Material

• Órdenes para invocar una display list (lista de órdenes):– CallList– CallLists

• Orden EdgeFlag



• Cualquier otra operación devolverá un error: INVALID_OPERATION

• Operaciones NO permitidas entre Begin/End: EnableClientState, DisableClientState, PushClientAttrib, PopClientAttrib, ColorPointer, FogCoordPointer, EdgeFlagPointer, IndexPointer, NormalPointer, TexCoordPointer, SecondaryColorPointer, VertexPointer, VertexAttribPointer, ClientActiveTexture,InterleavedArrays y PixelStore

• Ejecutar un Begin dentro de Begin/End genera error• Ejecutar End sin un Begin previo genera error


2.6. Especificación de Vértices

• Creación de un vértice en 2, 3 ó 4 coordenadas:– void Vertex{234}{sifd}( T coords );– void Vertex{234}{sifd}v( T coords );

• Especificar Coordenadas de textura– void TexCoord{1234}{sifd}( T coords );– void TexCoord{1234}{sifd}v( T coords );

• Especificar Multitextura– void MultiTexCoord{1234}{sifd}(enum texture,T coords)– void MultiTexCoord{1234}{sifd}v(enum texture,T coords)– texture = TEXTUREi

• Asignar normales– void Normal3{bsifd}( T coords );– void Normal3{bsifd}v( T coords );



• Coordenadas de Niebla– void FogCoord{fd}( T coord );– void FogCoord{fd}v( T coord );

• Colores en Modo RGBA– void Color{34}{bsifd ubusui}( T components );– void Color{34}{bsifd ubusui}v( T components );– void SecondaryColor3{bsifd ubusui}( T components );– void SecondaryColor3{bsifd ubusui}v( T components );

• Colores en Modo color index– void Index{sifd ub}( T index );– void Index{sifd ub}v( T index );



• Carga de Atributos genéricos de vérticesvoid VertexAttrib{1234}{sfd}( uint index, T values );

void VertexAttrib{123}{sfd}v( uint index, T values );

void VertexAttrib4{bsifd ubusui}v( uint index, T values );


2.7 Vertex Arrays

• Datos de vértices almacenados en arrays– Espacio del cliente– Usados en múltiples primitivas– Posibles datos: coordenadas de vértices,

normales, colores, colores secundarios, índices de colores, flags de bordes, coordenadas de niebla, coordenadas de texturas, atributos genéricos de vértices.


2.7 Vertex Arrays

• Para lolalizar y organizar arrays:– void VertexPointer( int size, enum type, sizei stride, void

*pointer );– void NormalPointer( enum type, sizei stride, void *pointer );– void ColorPointer( int size, enum type, sizei stride, void

*pointer );– void SecondaryColorPointer( int size, enum type, sizei stride,

void *pointer );– void IndexPointer( enum type, sizei stride, void *pointer);– void EdgeFlagPointer( sizei stride, void *pointer );– void FogCoordPointer( enum type, sizei stride, void *pointer );– void TexCoordPointer( int size, enum type, sizei stride, void

*pointer );– void VertexAttribPointer( uint index, int size, enum type,

boolean normalized, sizei stride, const void *pointer );


2.8 Buffer Objects

• Almacenar Datos del cliente en el servidor– Construir Buffer

• void BindBuffer( enum target, uint buffer );

– Borrar Buffer• void DeleteBuffers( sizei n, const uint *buffers );

– Obtener n buffers anteriores no utilizados• void GenBuffers( sizei n, uint *buffers );

– Almacenar datos• void BufferData( enum target, sizeiptr size, const void *data, enum

usage );

– Modificar datos• void BufferSubData( enum target, intptr offset, sizeiptr size, const

void *data );

– Actualizar cliente• void *MapBuffer( enum target, enum access );• boolean UnmapBuffer( enum target );


2.9 Rectangles

• A partir de dos esquinas:– void Rect{sifd}( T x1, T y1, T x2, T y2 );– void Rect{sifd}v( T v1[2], T v2[2] );

• Ejemplo:Rect (x1, y1, x2, y2);

– Equivalente a:

Begin(POLYGON);Vertex2(x1, y1);Vertex2(x2, y1);Vertex2(x2, y2);Vertex2(x1, y2);

End();


2.10 Transformaciones de coordenadas

• Coordenadas de vértices, normales y texturas se transforman antes de que se usen para producir una imagen en el framebuffer.



• Coordenadas de objeto, coordenadas de ojo, y coordenadas de clip son 4-D: (x, y, z, w)

• La matriz del modelo de vista y la matriz de proyección son de tamaño 4x4

• Coordenadas de objeto Coordenadas de ojo

= M donde M es la matriz del modelo de vista

X0

y0

z0

w0

Xe

ye

ze

we



• Coordenadas de ojo Coordenadas de clip

= P donde P es la matriz del proyección

• Coordenadas normalizadas:

=

Xe

ye

ze

we

Xc

yc

zc

wc

xc/wc

yc/wc

zc /wc

xd

yd

zd


2.10.1. Control del viewport

• La transformación al campo de visualización (viewport transformation) se determina por:– ancho y alto en píxeles: (px, py)– Centro de referencia: (ox, oy)– Las coordenadas de ventana se calculan:

=

donde f y n [0,1] se establecen mediante:void DepthRange( clampd n, clampd f );

(px / 2 )xd + ox

(py / 2 )yd + oy

[(f − n)/2] zd + (n + f)/2

xw

yw

zw


2.10.1. Control del viewport

• Los parámetros de configuración del viewport se especifican mediante:void Viewport( int x, int y, sizei w, sizei h );

donde:

(x, y): esquina inferior izquierda de la ventana

(w, h): ancho y alto de ventana

• A partir de estos valores calculamos el resto de parámetros del viewport:

ox = x + w/2

oy = y + h/2

px = w

py = h


2.10.2. Matrices

• Elección de la matriz a modificarvoid MatrixMode( enum mode );

donde:

mode = TEXTURE, MODELVIEW, COLOR, PROJECTION

• Modificación de matrices:void LoadMatrix{fd}( T m[16] ); //Intercambia matriz

void MultMatrix{fd}( T m[16] ); //Multiplica matriz

donde:

a1 a5 a9 a13

m = a2 a6 a10 a14

a3 a7 a11 a15

a4 a8 a12 a16


2.10.2. Matrices

• Transpuesta:– LoadTransposeMatrix[fd](m);– LoadMatrix[fd](mT );

• Multiplicar matriz transpuesta:– MultTransposeMatrix[fd](m);– MultMatrix[fd](mT );

• Cargar Identidad:– void LoadIdentity( void );

• Manipular Matrices:– void Rotate{fd}( T , T x, T y, T z );

: ángulo en grados

v = (x y z): vector de giro


2.10.2. Matrices

• Manipular Matrices (continuación)– void Rotate{fd}( T , T x, T y, T z );

: ángulo en gradosv = (x y z): vector de giro

– void Translate{fd}( T x, T y, T z );– void Scale{fd}( T x, T y, T z );– void Frustum( double l, double r, double b, double t, double

n, double f );donde:

(l b − n), (r t − n) coordenadas de clipping cercanas(l b − f), (r t − f) coordenadas de clipping lejanas

– Matriz de proyección paralela:void Ortho(double l, double r, double b, double t,

double n, double f);


2.10.2. Matrices

• Activar textura:– void ActiveTexture( enum texture );

• Almacenar matrices en la pila– void PushMatrix( void );– void PopMatrix( void );

• Reescalado y normalización:– void Enable( enum target );– void Disable( enum target );

• Generar coordenadas de textura:– void TexGen{ifd}( enum coord, enum pname, T param );– void TexGen{ifd}v( enum coord, enum pname, T params );

• pname:TEXTURE_GEN_MODE, OBJECT_PLANE, EYE_PLANE• params: valores ó OBJECT_LINEAR, EYE_LINEAR (por defecto), SPHERE_MAP, REFLECTION_MAP, NORMAL_MAP.


2.11 Clipping

• Las primitivas son ajustadas al volumen de corte (clip volume).

• Volumen de vista (view volume) viene definido por:− wc xc wc

− wc yc wc

− wc zc wc

• Por defecto, el volumen de corte es el volumen de vista

• Se puede definir un plano de corte cliente:– void ClipPlane( enum p, double eqn[4] );

• p: identifica plano de corte cliente CLIP_PLANEi, i [0,.., n-1]

• eqn: coeficientes de la ecuación de un plano en coordenadas de objeto: (p1, p2, p3, p4)


2.12 Current Raster Position

• La posición actual de renderizado se puede obtener mediante:– void RasterPos{234}{sifd}( T coords );– void RasterPos{234}{sifd}v( T coords );

• Se usa por órdenes que afectan directamente a los píxeles del framebuffer

• Se puede modificar la posición actual:– void WindowPos{23}{ifds}( T coords );– void WindowPos{23}{ifds}v( const T coords );


2.13 Colores

• Proceso de colores RGBA e índices de color anterior a la rasterización:


2.13.1 Iluminación

• La iluminación de OpenGL calcula los colores por vértices

• Sentido de la luz (front color / back color) :– void FrontFace( enum dir );

• Aplica la dirección en el sentido de las agujas del reloj o al contrario (igual que los polígonos):– CCW (counter-clockwise orientation)


2.13.2 Especificación de parámetros de luz

• void Material{if}( enum face, enum pname, T param );• void Material{if}v( enum face, enum pname, T

params );• void Light{if}( enum light, enum pname, T param );• void Light{if}v( enum light, enum pname, T params );• void LightModel{if}( enum pname, T param );• void LightModel{if}v( enum pname, T params );

– pname: identifica el parámetro a modificar

– face: FRONT, BACK ó FRONT_AND_BACK,

– light: LIGHTi, i [0,.., n-1], identifica una luz concreta.


2.13.3 ColorMaterial

• Es posible aplicar más de una propiedad de material

• El modo se selecciona mediante:– void ColorMaterial( enum face, enum mode );

• face: FRONT, BACK, ó FRONT_AND_BACK,• mode: EMISSION, AMBIENT, DIFFUSE, SPECULAR, ó

AMBIENT_AND_DIFFUSE

– Ejemplo:• ColorMaterial(FRONT, AMBIENT)


3. Rasterización

• Rasterización (= renderización = representación) es el proceso por el cual una primitiva es transformada en una imagen de dos dimensiones

• Cada punto de esta imagen contiene información como color y profundidad (número de bits de colores)

• El proceso consiste en dos pasos:– Determinar qué zona (conjunto de píxeles) en coordenadas

de ventana está ocupada por la primitiva.– Asignar un valor de profundidad y uno o más valores de

color para cada píxel.


3. Rasterización


3. Rasterización3.1. Puntos

• void PointSize( float size );

• Rasterización punto:

desfase


3.1. Puntos


3.2. Segmentos

• void LineWidth( float width );


3.3. Polígonos

• void CullFace( enum mode );– Mode = FRONT, BACK ó FRONT_AND_BACK


3.4. Bitmaps

• void Bitmap( sizei w, sizei h, float xbo, float ybo, float xbi, float ybi, ubyte *data );


3.5. Texturas

• Especificación de la imagen de textura– void TexImage3D( enum target, int level, int internalformat,

sizei width, sizei height, sizei depth, int border, enum format, enum type, void *data );

• target = TEXTURE 3D, or PROXY TEXTURE 3D• format, type, y data: argumentos para DrawPixels

– void DrawPixels( sizei width, sizei height, enum format, enum type, void *data );

• Tamaño imagen: width, height• Nivel de detalle: level

– void TexImage2D( enum target, int level, int internalformat, sizei width, sizei height, int border, enum format, enum type, void *data );

– void TexImage1D( enum target, int level, int internalformat, sizei width, int border, enum format, enum type, void *data );


3.5. Texturas


3.5. Texturas

Modificar una región rectangular:• void TexSubImage3D( enum target, int level, int xoffset, int

yoffset, int zoffset, sizei width, sizei height, sizei depth, enum format, enum type, void *data );

• void TexSubImage2D( enum target, int level, int xoffset, int yoffset, sizei width, sizei height, enum format, enum type, void *data );

• void TexSubImage1D( enum target, int level, int xoffset, sizei width, enum format, enum type, void *data );

• void CopyTexSubImage3D( enum target, int level, int xoffset, int yoffset, int zoffset, int x, int y, sizei width, sizei height );

• void CopyTexSubImage2D( enum target, int level, int xoffset, int yoffset, int x, int y, sizei width, sizei height );

• void CopyTexSubImage1D( enum target, int level, int xoffset, int x, int y, sizei width );


3.5. Texturas

• Imágenes comprimidas:– void CompressedTexImage1D( enum target, int level,

enum internalformat, sizei width, int border, sizei imageSize, void *data );

– void CompressedTexImage2D( enum target, int level, enum internalformat, sizei width, sizei height, int border, sizei imageSize, void *data );

– void CompressedTexImage3D( enum target, int level, enum internalformat, sizei width, sizei height, sizei depth, int border, sizei imageSize, void *data );

– GetCompressedTexImage

• Crear una textura:– void BindTexture( enum target, uint texture );


3.5. Texturas

• Parámetros de textura:– void TexParameter{if}( enum target, enum

pname, T param );– void TexParameter{if}v( enum target, enum

pname, T params );• target = TEXTURE 1D, TEXTURE 2D, TEXTURE 3D, o

TEXTURE CUBE MAP.• pname: parámetro a modificar• params: valores


3.5. Texturas

• Entorno de textura– void TexEnv{if}( enum target, enum pname, T

param );– void TexEnv{if}v( enum target, enum pname, T

params );


3.5. Texturas

• Borrar texturas:– void DeleteTextures( sizei n, uint

*textures );

• Texturas no utilizadas:– void GenTextures( sizei n, uint *textures );


Referencias• The OpenGL Graphics System: A Specification (Version 2.0 -

October 22, 2004) Mark Segal, Kurt Akeley• OpenGL Getting Started FAQ

http://www.opengl.org/resources/faq/getting_started.html• OpenGL Win32 Tutorial

http://www.nullterminator.net/opengl32.html• Terry OpenGL linux Tutorial

http://www.eecs.tulane.edu/www/Terry/OpenGL/• Nehe Tutorial

http://nehe.gamedev.net/• OpenGL & OpenGL Utilities Specification

http://www.opengl.org/documentation/spec.html?1.1/glspec.html• Página Principal Máster:

http://www.uem.es/mastervideojuegos/• Página Principal Máster - OpenGL:

www.esp.uem.es/~gonzalo/opengl


Bibliografía

• The OpenGL Reference Manual: The Official Reference Document to OpenGL, Version 1.2 (3rd Edition) (Paperback) by Dave Shreiner, Opengl Architecture Review Board

• The OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 1.2 (3rd Edition) (Paperback) by Mason Woo

máster en creación y producción de videojuegos opengl gonzalo mariscal vivas gonzalo/opengl

Documents