Mster en Creacin y Produccin de Videojuegos

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

• OpenGL
• Gonzalo Mariscal Vivashttp//www.esi.uem.es/gonz
  alo/opengl

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

3
Introducción

• 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

4
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

5
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

6
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.

7
2.1. Fundamentos de OpenGL

• Órdenes (procedimientos o funciones) para la
  especificación de objetos geométricos en 2D ó 3D
• 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

8
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 gt 2D)

9
2.2. Sintaxis de las órdenes GL

• Nomenclatura
• Órdenes comienzan por gl
• Constantes comienzan por GL_
• Tipos comienzan por GL

10
2.2. Sintaxis de las órdenes GL

• Órdenes incluyen tipos de parámetros
• void Vertex3f( float x, float y, float z )
• void Vertex2sv( short v2 )
• 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

11
2.2. Sintaxis de las órdenes GL

• Las letras definen tipos GL

12
2.2. Sintaxis de las órdenes GL

• Descripción de tipos GL

13
2.3. Operaciones GL básicas

• Pipeline del proceso de órdenes

14
2.4. Errores GL

• enum GetError( void )
• Resumen de Errores

15
2.5. Paradigma Begin / End

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

16
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

17
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.

18
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.

19
2.5.1. Begin / End
20
2.5.1. Begin / End

• Quadrilateral (quad) strips
• Se construyen los cuadrados compartiendo dos
  vértices con el anterior
• modeQUAD_STRIP
• Separate quads
• Se agrupan los vértices de cuatro en cuatro
• modeQUADS

21
2.5.1. Begin / End

• Quadrilaterals

22
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

23
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

24
2.5.3 Órdenes GL entre pares Begin/End

• 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

25
2.5.3 Órdenes GL entre pares Begin/End

• 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,Interleav
  edArrays y PixelStore
• Ejecutar un Begin dentro de Begin/End genera
  error
• Ejecutar End sin un Begin previo genera error

26
2.6. Especificación de Vértices

• Creación de un vértice en 2, 3 ó 4 coordenadas
• void Vertex234sifd( T coords )
• void Vertex234sifdv( T coords )
• Especificar Coordenadas de textura
• void TexCoord1234sifd( T coords )
• void TexCoord1234sifdv( T coords )
• Especificar Multitextura
• void MultiTexCoord1234sifd(enum texture,T
  coords)
• void MultiTexCoord1234sifdv(enum texture,T
  coords)
• texture TEXTUREi
• Asignar normales
• void Normal3bsifd( T coords )
• void Normal3bsifdv( T coords )

27
2.6. Especificación de Vértices

• Coordenadas de Niebla
• void FogCoordfd( T coord )
• void FogCoordfdv( T coord )
• Colores en Modo RGBA
• void Color34bsifd ubusui( T components )
• void Color34bsifd ubusuiv( T components )
• void SecondaryColor3bsifd ubusui( T components
  )
• void SecondaryColor3bsifd ubusuiv( T components
  )
• Colores en Modo color index
• void Indexsifd ub( T index )
• void Indexsifd ubv( T index )

28
2.6. Especificación de Vértices

• Carga de Atributos genéricos de vértices
• void VertexAttrib1234sfd( uint index, T
  values )
• void VertexAttrib123sfdv( uint index, T
  values )
• void VertexAttrib4bsifd ubusuiv( uint index, T
  values )

29
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.

30
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 )

31
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 )

32
2.9 Rectangles

• A partir de dos esquinas
• void Rectsifd( T x1, T y1, T x2, T y2 )
• void Rectsifdv( T v12, T v22 )
• Ejemplo
• Rect (x1, y1, x2, y2)
• Equivalente a
• Begin(POLYGON)
• Vertex2(x1, y1)
• Vertex2(x2, y1)
• Vertex2(x2, y2)
• Vertex2(x1, y2)
• End()

33
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.

34
2.10 Transformaciones de coordenadas

• 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
35
2.10 Transformaciones de coordenadas

• 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
36
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
37
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

38
2.10.2. Matrices

• Elección de la matriz a modificar
• void MatrixMode( enum mode )
• donde
• mode TEXTURE, MODELVIEW, COLOR, PROJECTION
• Modificación de matrices
• void LoadMatrixfd( T m16 ) //Intercambia
  matriz
• void MultMatrixfd( T m16 ) //Multiplica
  matriz
• donde
• a1 a5 a9 a13
• m a2 a6 a10 a14
• a3 a7 a11 a15
• a4 a8 a12 a16

39
2.10.2. Matrices

• Transpuesta
• LoadTransposeMatrixfd(m)
• LoadMatrixfd(mT )
• Multiplicar matriz transpuesta
• MultTransposeMatrixfd(m)
• MultMatrixfd(mT )
• Cargar Identidad
• void LoadIdentity( void )
• Manipular Matrices
• void Rotatefd( T ?, T x, T y, T z )
• ? ángulo en grados
• v (x y z) vector de giro

40
2.10.2. Matrices

• Manipular Matrices (continuación)
• void Rotatefd( T ?, T x, T y, T z )
• ? ángulo en grados
• v (x y z) vector de giro
• void Translatefd( T x, T y, T z )
• void Scalefd( 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)

41
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 TexGenifd( enum coord, enum pname, T param
  )
• void TexGenifdv( enum coord, enum pname, T
  params )
• pnameTEXTURE_GEN_MODE, OBJECT_PLANE, EYE_PLANE
• params valores ó OBJECT_LINEAR, EYE_LINEAR (por
  defecto), SPHERE_MAP, REFLECTION_MAP, NORMAL_MAP.

42
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 eqn4 )
• 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)

43
2.12 Current Raster Position

• La posición actual de renderizado se puede
  obtener mediante
• void RasterPos234sifd( T coords )
• void RasterPos234sifdv( T coords )
• Se usa por órdenes que afectan directamente a los
  píxeles del framebuffer
• Se puede modificar la posición actual
• void WindowPos23ifds( T coords )
• void WindowPos23ifdsv( const T coords )

44
(No Transcript)
45
2.13 Colores

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

46
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)

47
2.13.2 Especificación de parámetros de luz

• void Materialif( enum face, enum pname, T param
  )
• void Materialifv( enum face, enum pname, T
  params )
• void Lightif( enum light, enum pname, T param
  )
• void Lightifv( enum light, enum pname, T params
  )
• void LightModelif( enum pname, T param )
• void LightModelifv( 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.

48
(No Transcript)
49
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)

50
(No Transcript)
51
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.

52
3. Rasterización
53
3. Rasterización3.1. Puntos

• void PointSize( float size )
• Rasterización punto

desfase
54
3.1. Puntos
55
3.2. Segmentos

• void LineWidth( float width )

56
3.3. Polígonos

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

57
3.4. Bitmaps

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

58
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 )

59
3.5. Texturas
60
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 )

61
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 )

62
3.5. Texturas

• Parámetros de textura
• void TexParameterif( enum target, enum pname, T
  param )
• void TexParameterifv( enum target, enum pname,
  T params )
• target TEXTURE 1D, TEXTURE 2D, TEXTURE 3D, o
  TEXTURE CUBE MAP.
• pname parámetro a modificar
• params valores

63
(No Transcript)
64
3.5. Texturas

• Entorno de textura
• void TexEnvif( enum target, enum pname, T param
  )
• void TexEnvifv( enum target, enum pname, T
  params )

65
3.5. Texturas

• Borrar texturas
• void DeleteTextures( sizei n, uint textures )
• Texturas no utilizadas
• void GenTextures( sizei n, uint textures )

66
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/r
  esources/faq/getting_started.html
• OpenGL Win32 Tutorial http//www.nullterminator.ne
  t/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

67
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