1 / 67

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

Máster en Creación y Producción de Videojuegos. OpenGL Gonzalo Mariscal Vivas http://www.esi.uem.es/~gonzalo/opengl. OpenGL - Índice. 1. Introducción 2. Operaciones OpenGL 3. Rasterización / Renderizado 4. Per-Fragment Operations and the Framebuffer 5. Special Functions

carrie
Télécharger la présentation

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

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Máster en Creación y Producción de Videojuegos OpenGL Gonzalo Mariscal Vivashttp://www.esi.uem.es/~gonzalo/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 OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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] OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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 OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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 OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  6. Sistema Operativo Usuario OpenGL Framebuffer 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 – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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 OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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 => 2D) OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  9. 2.2.Sintaxis de las órdenes GL • Nomenclatura: • Órdenes comienzan por “gl” • Constantes comienzan por “GL_” • Tipos comienzan por “GL” OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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 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 OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  11. 2.2.Sintaxis de las órdenes GL • Las letras definen tipos GL: OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  12. 2.2.Sintaxis de las órdenes GL • Descripción de tipos GL: OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  13. 2.3.Operaciones GL básicas • Pipeline del proceso de órdenes: OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  14. 2.4.Errores GL • enum GetError( void ); • Resumen de Errores: OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  15. 2.5. Paradigma Begin / End • void Begin( enum mode ); • void End( void ); OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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 OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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. • TriangleStrips. • 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. OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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. OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  19. 2.5.1. Begin / End OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  20. 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 OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  21. 2.5.1. Begin / End • Quadrilaterals OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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” OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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 OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  24. 2.5.3 Órdenes GL entre pares Begin/End • Coordenadas de niebla • FogCoord • Vector de Elementos • ArrayElement • Órdenes EvalCoordy EvalPoint • Órdenes para especificar parámetros iluminación de materiales: • Material • Órdenes para invocar una display list (lista de órdenes): • CallList • CallLists • OrdenEdgeFlag OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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,InterleavedArrays y PixelStore • Ejecutar un Begin dentro de Begin/End genera error • Ejecutar End sin un Begin previo genera error OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  26. 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 ); OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  27. 2.6. Especificación de Vértices • 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 ); OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  28. 2.6. Especificación de Vértices • Carga de Atributos genéricos de vértices void 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 ); OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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. OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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 ); OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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 ); OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  32. 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(); OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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. OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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 Xe ye ze we X0 y0 z0 w0 OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  35. 2.10 Transformaciones de coordenadas • Coordenadas de ojo  Coordenadas de clip = P donde P es la matriz del proyección • Coordenadas normalizadas: = Xc yc zc wc Xe ye ze we xd yd zd xc/wc yc/wc zc /wc OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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 ); xw yw zw (px / 2 )xd + ox (py / 2 )yd + oy [(f − n)/2] zd + (n + f)/2 OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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 OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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 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 OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  39. 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 OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  40. 2.10.2. Matrices • Manipular Matrices (continuación) • void Rotate{fd}( T , T x, T y, T z ); : ángulo en grados v = (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); OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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 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. OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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 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) OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  43. 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 ); OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  44. OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  45. 2.13 Colores • Proceso de colores RGBA e índices de color anterior a la rasterización: OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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) OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  47. 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. OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  48. OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  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) OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

  50. OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

More Related