m ster en creaci n y producci n de videojuegos
Download
Skip this Video
Download Presentation
Máster en Creación y Producción de Videojuegos

Loading in 2 Seconds...

play fullscreen
1 / 67

Máster en Creación y Producción de Videojuegos - PowerPoint PPT Presentation


  • 64 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Máster en Creación y Producción de Videojuegos' - tara-henderson


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
m ster en creaci n y producci n de videojuegos

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

OpenGL

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

opengl ndice
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

introducci n
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

introducci n1
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

introducci n2
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

2 operaciones opengl 2 1 fundamentos de opengl
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

2 1 fundamentos de opengl
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

2 1 fundamentos de opengl1
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

2 2 sintaxis de las rdenes gl
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

2 2 sintaxis de las rdenes gl1
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

2 2 sintaxis de las rdenes gl2
2.2.Sintaxis de las órdenes GL
  • Las letras definen tipos GL:

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

2 2 sintaxis de las rdenes gl3
2.2.Sintaxis de las órdenes GL
  • Descripción de tipos GL:

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

2 3 operaciones gl b sicas
2.3.Operaciones GL básicas
  • Pipeline del proceso de órdenes:

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

2 4 errores gl
2.4.Errores GL
  • enum GetError( void );
    • Resumen de Errores:

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

2 5 paradigma begin end
2.5. Paradigma Begin / End
  • void Begin( enum mode );
  • void End( void );

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

2 5 1 begin end
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

2 5 1 begin end1
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

2 5 1 begin end2
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

2 5 1 begin end3
2.5.1. Begin / End

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

2 5 1 begin end4
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

2 5 1 begin end5
2.5.1. Begin / End
  • Quadrilaterals

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

2 5 2 polygon edges
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

2 5 3 rdenes gl entre pares begin end
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

2 5 3 rdenes gl entre pares begin end1
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

2 5 3 rdenes gl entre pares begin end2
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

2 6 especificaci n de v rtices
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

2 6 especificaci n de v rtices1
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

2 6 especificaci n de v rtices2
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

2 7 vertex arrays
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

2 7 vertex arrays1
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

2 8 buffer objects
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

2 9 rectangles
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

2 10 transformaciones de coordenadas
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

2 10 transformaciones de coordenadas1
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

2 10 transformaciones de coordenadas2
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

2 10 1 control del viewport
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

2 10 1 control del viewport1
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

2 10 2 matrices
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

2 10 2 matrices1
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

2 10 2 matrices2
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

2 10 2 matrices3
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

2 11 clipping
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

2 12 current raster position
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

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

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

2 13 1 iluminaci 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)

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

2 13 2 especificaci n de par metros de luz
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

2 13 3 colormaterial
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

3 rasterizaci n
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.

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

3 rasterizaci n1
3. Rasterización

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

3 rasterizaci n 3 1 puntos
3. Rasterización3.1. Puntos
  • void PointSize( float size );
  • Rasterización punto:

desfase

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

3 1 puntos
3.1. Puntos

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

3 2 segmentos
3.2. Segmentos
  • void LineWidth( float width );

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

3 3 pol gonos
3.3. Polígonos
  • void CullFace( enum mode );
    • Mode = FRONT, BACK ó FRONT_AND_BACK

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

3 4 bitmaps
3.4. Bitmaps
  • void Bitmap( sizei w, sizei h, float xbo, float ybo, float xbi, float ybi, ubyte *data );

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

3 5 texturas
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 );

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

3 5 texturas1
3.5. Texturas

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

3 5 texturas2
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 );

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

3 5 texturas3
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 );

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

3 5 texturas4
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

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

3 5 texturas5
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 );

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

3 5 texturas6
3.5. Texturas
  • Borrar texturas:
    • void DeleteTextures( sizei n, uint *textures );
  • Texturas no utilizadas:
    • void GenTextures( sizei n, uint *textures );

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

referencias
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

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

bibliograf a
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

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid

ad