M ster en creaci n y producci n de videojuegos
Download
1 / 67

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


  • 62 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 Madrid

  • 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 Madrid

  • 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 Madrid

  • 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 Madrid

  • 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 Madrid

  • 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 Madrid

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid


3 rasterizaci n 3 1 puntos
3. Rasterización Madrid3.1. Puntos

  • void PointSize( float size );

  • Rasterización punto:

desfase

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid


3 1 puntos
3.1. Puntos Madrid

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid


3 2 segmentos
3.2. Segmentos Madrid

  • void LineWidth( float width );

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid


3 3 pol gonos
3.3. Polígonos Madrid

  • void CullFace( enum mode );

    • Mode = FRONT, BACK ó FRONT_AND_BACK

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid


3 4 bitmaps
3.4. Bitmaps Madrid

  • 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 Madrid

  • 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 Madrid

OpenGL – Gonzalo Mariscal Vivas – Universidad Europea Madrid


3 5 texturas2
3.5. Texturas Madrid

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 Madrid

  • 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 Madrid

  • 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 Madrid

  • 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 Madrid

  • 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 Madrid

  • 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 Madrid

  • 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