SISTEMAS GRÁFICOS

GRUPO DE PROCESADO DE IMAGEN Y REALIDAD VIRTUALETSI Telecomunicación. Universidad de Vigo

TMM: Tecnoloxia Multimedia. 2006

Donde Estamos?Generalidades

● Gráficos InteractivosGráficos Interactivos– Interfaces herramientas CADInterfaces herramientas CAD

– Interfaces herramientas de Modelado 3DInterfaces herramientas de Modelado 3D

– EntretenimientoEntretenimiento

– InterioresInteriores

– etc...etc...

Donde NO Estamos?Generalidades

● Imágen FotorealistaImágen Fotorealista– PelículasPelículas

– Post ProducciónPost Producción

● TécnicasTécnicas– Ray­Tracing (POV Ray)Ray­Tracing (POV Ray)

Arquitectura Hardware IGeneralidades

● CPUCPU● RAMRAM● BUSBUS● VRAMVRAM● GPUGPU● DACDAC

RAM

Tarjeta Gráfica

CPU

BUS (PCI, AGP, PCI Express)

Arquitectura Hardware IIGeneralidades

● Lee datos RAMLee datos RAM

● Escribe VRAM a través del Bus PCIEscribe VRAM a través del Bus PCI

● GPU lee VRAMGPU lee VRAM

● DAC genera señal de VideoDAC genera señal de Video

RAM

VRAM GPU DAC

CPU

VRAM Dual­Port MemoryFlicker – Retrazo VerticalPCI : 133 MB/s

BUS PCI/ISA/VESA LB

Arquitectura Hardware IIIGeneralidades

● GPU accede directamente a la RAM del equipoGPU accede directamente a la RAM del equipo

● Tarjeta Gráfica tiene memoria localTarjeta Gráfica tiene memoria local

● GPU procesador complejoGPU procesador complejoRAM

VRAM GPU DAC

CPU

Velocidades de bus

AGP x4 : 1 GB/sAGP x8: 2.1 GB/sPCI­Express (x16): 4GB/s

BUS AGP/PCI Express

Arquitectura Hardware IVGeneralidades

● MultiGPUMultiGPU– Permiten la conexión de varias tarjetas de videoPermiten la conexión de varias tarjetas de video

Mejora del rendimientoMejora del rendimiento

– Dos Soluciones: ATI CrossFire y nVidia SLIDos Soluciones: ATI CrossFire y nVidia SLI

Arquitectura Hardware VGeneralidades

● SLI: Scalable Link InterfaceSLI: Scalable Link Interface– Require 2 PCI­Express x16Require 2 PCI­Express x16

– 2 o 4 tarjetas (QUAD SLI)2 o 4 tarjetas (QUAD SLI)

– Tarjetas idénticas conectadas por una PCBTarjetas idénticas conectadas por una PCB

– Formas de trabajo:Formas de trabajo:● SFR: Split Frame RenderingSFR: Split Frame Rendering● AFR: Alternate Frame RenderingAFR: Alternate Frame Rendering

Arquitectura Hardware IVGeneralidades

● ATI Cross­FireATI Cross­Fire– Las tarjetas no tienen que ser idénticasLas tarjetas no tienen que ser idénticas

– Master Card Composition chipMaster Card Composition chip

– Modos de Funcionamiento:Modos de Funcionamiento:● Super TilingSuper Tiling● Scissor (SFR)Scissor (SFR)● Alternate Frame Rendering (AFR)Alternate Frame Rendering (AFR)● CrossFire SuperAACrossFire SuperAA

Arquitectura Hardware VGeneralidades

● ATI Cross­Fire. DiagramaATI Cross­Fire. Diagrama

Matemáticas IGeneralidades

● Coordenadas HomogéneasCoordenadas Homogéneas– Permiten representar transformaciones Permiten representar transformaciones 

afines como operaciones con matricesafines como operaciones con matrices

– Transformaciones Afines: Transformaciones Afines: Transformación lineal + TraslaciónTransformación lineal + Traslación

● Rotación, Escalado, Proyección...Rotación, Escalado, Proyección...

– Transformar un vector en coordenadas homogéneas =Transformar un vector en coordenadas homogéneas == = Multiplicarlo por la matrizMultiplicarlo por la matriz

– Composición de Transformaciones = Composición de Transformaciones = = = Producto de MatricesProducto de Matrices

Coordenadas Homogéneas(x, y, z) ­> (x, y, z, 1)Transformación Afín

x ­> Ax +bMatriz de Transformación

A   b0   1

Matemáticas IIGeneralidades

● QuaternionsQuaternions– Se pueden ver como una generalización de los númerosSe pueden ver como una generalización de los números

complejoscomplejos

– Representan rotaciones respecto a un eje Representan rotaciones respecto a un eje 

– Utilizados para realizar rotaciones suaves:Utilizados para realizar rotaciones suaves:● Spherical Linear Interpolation (SLERP)Spherical Linear Interpolation (SLERP)

Quaternionv = a + b∙i + c∙j + d∙k = a + u

Propiedadesi*i = j*j = k*k = ­1

ij=k, jk=i, ki=jji=­k, kj=­i, ik=­j

IntroduccionOpenGL

● API de bajo nivel (primitivas gráficas sencillas)API de bajo nivel (primitivas gráficas sencillas)● Utilidades de mas alto nivel GLU, GLUTUtilidades de mas alto nivel GLU, GLUT

– Utility and Utility ToolkitUtility and Utility Toolkit

● No proporciona Widgets/VentanasNo proporciona Widgets/Ventanas– Se requiere un interfaz con el sistema de ventanas Se requiere un interfaz con el sistema de ventanas 

(glx/wglx, SDL, glut,...)(glx/wglx, SDL, glut,...)

● Alternativa: Alternativa: – Microsoft DirectX (Direct3D) Microsoft DirectX (Direct3D) 

NotasDesarrollado por SGI en 1992

Soportado en la mayoriade plataformas existentes en

la actualidad

Introduccion OpenGL

● La especificacion la gestiona el Architecture La especificacion la gestiona el Architecture Review Board (ARB)Review Board (ARB)

● Existen varias extensiones a la especificacionExisten varias extensiones a la especificacion– ARB, NV, HP, SGI, etc...ARB, NV, HP, SGI, etc...

● Dos libros para empezar:Dos libros para empezar:– Libro Rojo (Libro Rojo (RedbookRedbook):):

OpenGL Programming GuideOpenGL Programming Guide

– Libro Azul (Libro Azul (BlueBookBlueBook): ): OpenGL Reference ManualOpenGL Reference Manual Sitio Oficial

www.opengl.org

Aplicaciones GraficasOpenGL

● Estructura general de una aplicación GráficaEstructura general de una aplicación Gráfica– INICIALIZACIÓNINICIALIZACIÓN

– BUCLE INFINITO PRINCIPALBUCLE INFINITO PRINCIPAL● Lee EventosLee Eventos● Procesa EventosProcesa Eventos● Render FrameRender Frame● Duerme ProcesoDuerme Proceso

MatricesOpenGL. Conceptos Generales

● Trabajaremos con coordenadas homogéneas Trabajaremos con coordenadas homogéneas y matrices de transformación.y matrices de transformación.

● MatricesMatrices– PROJECTION_MATRIX: Prespectiva/ortonormalPROJECTION_MATRIX: Prespectiva/ortonormal

– MODELVIEW_MATRIX: RepresentaciónMODELVIEW_MATRIX: Representación

– TEXTURE_MATRIX: Manipulación de texturasTEXTURE_MATRIX: Manipulación de texturas

● OpenGL permite la manipulación sencilla de las OpenGL permite la manipulación sencilla de las matrices:matrices:

glTranslatef (4.0f, 0.0f, ­10.0f); ­> Genera una traslaciónglTranslatef (4.0f, 0.0f, ­10.0f); ­> Genera una traslación

BuffersOpenGL Conceptos Generales

● OpenGL gestiona diversos buffers necesarios para OpenGL gestiona diversos buffers necesarios para la representación de los gráficos:la representación de los gráficos:– COLOR_BUFFER: Imagen generadaCOLOR_BUFFER: Imagen generada

– Z_BUFFER: Información de profundidad de cada Z_BUFFER: Información de profundidad de cada pixel de la imagenpixel de la imagen

– STENCIL_BUFFER: Enmascarado de pixelsSTENCIL_BUFFER: Enmascarado de pixels

– ACCUMULATION_BUFFER: Buffer de acumulaciónACCUMULATION_BUFFER: Buffer de acumulación

Hola Mundo con GLUT IOpenGL Programacion

● Creando la ventanaCreando la ventana#include <GL/gl.h>#include <GL/gl.h>

#include <GL/glu.h>#include <GL/glu.h>

#include <GL/glut.h>#include <GL/glut.h>

int main (int argc, char *argv) {int main (int argc, char *argv) {

    glutInit (&argc, argv);glutInit (&argc, argv);

    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

    glutInitWindowSize (500, 500);glutInitWindowSize (500, 500);

    glutCreateWindow (argv[0]);glutCreateWindow (argv[0]);

    init ();init ();

    ......

Hola Mundo con GLUT IIOpenGL Programacion

● Preparando EventosPreparando Eventos    ......

    glutDisplayFunc (display);glutDisplayFunc (display);

    glutReshapeFunc(reshape);glutReshapeFunc(reshape);

    glutMainLoop();glutMainLoop();

    return 0;return 0;

}}

void init(void){void init(void){

    glClearColor (0.0f, 0.0f, 0.0f);glClearColor (0.0f, 0.0f, 0.0f);

    glShadeMode (GL_FLAT);glShadeMode (GL_FLAT);

}}

Hola Mundo con GLUT IIIOpenGL Programacion

● Render. La funcion displayRender. La funcion displayvoid display(void) {  void display(void) {  

      glClear (GL_COLOR_BUFFER_BIT);                                               glClear (GL_COLOR_BUFFER_BIT);                                               

      glColor3f (1.0, 1.0, 1.0);                                                   glColor3f (1.0, 1.0, 1.0);                                                   

      glLoadIdentity ();             /* clear the matrix viewing transform*/  glLoadIdentity ();             /* clear the matrix viewing transform*/  

      gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);   gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);                                       

      glScalef (1.0, 2.0, 1.0);      /* modeling transformation */        glScalef (1.0, 2.0, 1.0);      /* modeling transformation */                          

      glutWireCube (1.0);    glutWireCube (1.0);                                                                                                                

      glFlush ();glFlush ();      

}}

TransformacionesOpenGL Programacion

● Tres transformaciones:Tres transformaciones:– TranslacionesTranslaciones

● glTranslatef (desp_x, desp_y, desp_z);glTranslatef (desp_x, desp_y, desp_z);

– RotacionesRotaciones● glRotatef (angulo, x, y, z);glRotatef (angulo, x, y, z);

– EscaladoEscalado● glScalef (escala_x, escala_y, escala_z);glScalef (escala_x, escala_y, escala_z);

Hola Mundo con GLUT IIIOpenGL Programacion

● Cambiando ViewPort. Funcion reshapeCambiando ViewPort. Funcion reshapevoid reshape (int w, int h)                                                     void reshape (int w, int h)                                                     

{                                                                               {                                                                               

      glViewport (0, 0, (GLsizei) w, (GLsizei) h);                                 glViewport (0, 0, (GLsizei) w, (GLsizei) h);                                 

      glMatrixMode (GL_PROJECTION);   glMatrixMode (GL_PROJECTION);                                                                                             

      glLoadIdentity ();                                                           glLoadIdentity ();                                                           

      glFrustum (­1.0, 1.0, ­1.0, 1.0, 1.5, 20.0);                                 glFrustum (­1.0, 1.0, ­1.0, 1.0, 1.5, 20.0);                                 

      glMatrixMode (GL_MODELVIEW); glMatrixMode (GL_MODELVIEW);                                                                                                 

} } MATRIX DE PROJECCION

glFrustum: PrespectivaglOrtho: Ortografica

Hola Mundo con GLUT IIIOpenGL Programacion

● Proyeccion: Prespectiva y OrtograficaProyeccion: Prespectiva y Ortografica

MATRIX DE PROJECCIONglFrustum: PrespectivaglOrtho: Ortografica

Usando el Teclado IOpenGL Programacion

● Funcion de gestion de eventos de tecladoFuncion de gestion de eventos de teclado... /* En main */... /* En main */

glutKeyboardFunc (keyboard);glutKeyboardFunc (keyboard);

......

void keyboard (unsigned char key, int x, int y) {void keyboard (unsigned char key, int x, int y) {

switch (key) {switch (key) {

case 'a': case 'a': rotX += 10.0f;rotX += 10.0f;

break;break;

case 's':case 's': rotX ­= 10.0f rotX ­= 10.0f

break;break;

}}

glutPostRedisplay();glutPostRedisplay();

}}

Usando el Teclado IIOpenGL Programacion

● Nueva funcion displayNueva funcion displaystatic GLfloat   rotX;static GLfloat   rotX;

void display(void)   {                                                                               void display(void)   {                                                                               

      glClear (GL_COLOR_BUFFER_BIT);                                               glClear (GL_COLOR_BUFFER_BIT);                                               

      glColor3f (1.0, 1.0, 1.0);                                                   glColor3f (1.0, 1.0, 1.0);                                                   

      glLoadIdentity ();                       glLoadIdentity ();                       

      gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);                     gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);                     

      glScalef (1.0, 2.0, 1.0);   glScalef (1.0, 2.0, 1.0);   

      glRotatef (rotX, 1.0f, 0.0f, 0.0f);glRotatef (rotX, 1.0f, 0.0f, 0.0f);

      glutWireCube (1.0);                                                          glutWireCube (1.0);                                                          

      glFlush ();                                                                  glFlush ();                                                                  

}  }  

Usando el RatonOpenGL Programacion

● Funcion de gestion de eventos de ratonFuncion de gestion de eventos de raton... /* En main */... /* En main */

glutMouseFunc (mouse);glutMouseFunc (mouse);

......

void mouse (int button, int state, int x, int y) {void mouse (int button, int state, int x, int y) {

switch (button) {switch (button) {

case case GLUT_LEFT_BUTTONGLUT_LEFT_BUTTON: : 

if (state == if (state == GLUT_DOWNGLUT_DOWN) ) rotX += 10.0f;rotX += 10.0f;break;break;

case case GLUT_RIGHT_BUTTONGLUT_RIGHT_BUTTON::  

(...)}(...)}

glutPostRedisplay();glutPostRedisplay();

}}

GeometriasOpenGL Programacion

● Dibujando un Triangulo RojoDibujando un Triangulo Rojovoid triangle(void)void triangle(void)

{{

      glBeginglBegin ( (GL_TRIANGLESGL_TRIANGLES););

      glColor3f (1.0, 0.0, 0.0);glColor3f (1.0, 0.0, 0.0);

      glVertex2f (5.0, 5.0);glVertex2f (5.0, 5.0);

      glVertex2f (25.0, 5.0);glVertex2f (25.0, 5.0);

      glVertex2f (5.0, 25.0);glVertex2f (5.0, 25.0);

      glEndglEnd();();

}}

GL_POINTSGL_LINES

GL_LINE_STRIPGL_LINE_LOOPGL_TRIANGLES

GL_TRIANGLES_STRIPGL_TRIANGLES_FAN

GL_QUADSGL_QUAD_STRIP

GL_POLYGON

glVertex2{fd} (x, y)glVertex3{fd} (x, y, z)

glVertex4{fd} (x, y, z, w)

void init(void) {     glClearColor (0.0, 0.0, 0.0, 0.0);   glShadeModel (GL_FLAT);}

GeometriasOpenGL Programacion

● Primitivas de Dibujo GeometricoPrimitivas de Dibujo Geometrico

GL_POINTSGL_LINES

GL_LINE_STRIPGL_LINE_LOOPGL_TRIANGLES

GL_TRIANGLES_STRIPGL_TRIANGLES_FAN

GL_QUADSGL_QUAD_STRIP

GL_POLYGON

Geometrias y SombreadoOpenGL Programacion

● Triangulo de colorTriangulo de colorvoid triangle(void)void triangle(void)

{{

      glBegin (GL_TRIANGLES);glBegin (GL_TRIANGLES);

      glColor3f (1.0, 0.0, 0.0);glColor3f (1.0, 0.0, 0.0);

      glVertex2f (5.0, 5.0);glVertex2f (5.0, 5.0);

      glColor3f (0.0, 1.0, 0.0);glColor3f (0.0, 1.0, 0.0);

      glVertex2f (25.0, 5.0);glVertex2f (25.0, 5.0);

      glColor3f (0.0, 0.0, 1.0);glColor3f (0.0, 0.0, 1.0);

      glVertex2f (5.0, 25.0);glVertex2f (5.0, 25.0);

      glEnd();glEnd();

}}

void init(void) {     glClearColor (0.0, 0.0, 0.0, 0.0);   glShadeModel (GL_SMOOTH);}

Hidden-Surface RemovalOpenGL Programacion

● Uso del Z­BufferUso del Z­Bufferint main (int argc, char* argv[]) {int main (int argc, char* argv[]) {

    ......

    glutInitDisplayMode (glutInitDisplayMode (GLUT_DEPTH | GLUT_DEPTH | GLUT_SINGLE | GLUT_RGB);GLUT_SINGLE | GLUT_RGB);

    ......

}}

void display(void) {void display(void) {

      glClear (GL_COLOR_BIT glClear (GL_COLOR_BIT | GL_DEPTH_BUFFER_BIT| GL_DEPTH_BUFFER_BIT););

      /* Dibuja figuras solapadas *//* Dibuja figuras solapadas */

      ......

}}

Iluminacion IOpenGL Programacion

● Definicion de LucesDefinicion de Luces– Ambiente: Luz ambiental proveniente de todas Ambiente: Luz ambiental proveniente de todas 

direccionesdirecciones

– Difusa: Luz que proviene de una direccion y rebota en Difusa: Luz que proviene de una direccion y rebota en una superficie en todas direccionesuna superficie en todas direcciones

– Especular: Luz que proviene de una direccion y rebota Especular: Luz que proviene de una direccion y rebota en otra direccion definidaen otra direccion definida

● MaterialesMateriales– Definen la reflectancia ambiental, difusa y especular de Definen la reflectancia ambiental, difusa y especular de 

una superficieuna superficie

Iluminacion IIOpenGL Programacion

● Definiendo Luces y MaterialesDefiniendo Luces y Materialesvoid init(void) {

   GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };

   GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };

   GLfloat mat_shininess[] = { 50.0 };

   glClearColor (0.0, 0.0, 0.0, 0.0);

   glShadeModel (GL_SMOOTH);

   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);

   glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);

GL_SHININESSGL_AMBIENTGL_DIFUSSE

GL_SPECULARGL_EMISSION

GL_AMBIENT_AND_DIFFUSSE

Posicion lucesDireccional: w=0Posicional: w=1

Iluminacion IIIOpenGL Programacion

● Definiendo Luces y Materiales 2Definiendo Luces y Materiales 2   glLightfv(GL_LIGHT0, GL_POSITION, light_position);

   glEnable(GL_LIGHTING);

   glEnable(GL_LIGHT0);

   glEnable(GL_DEPTH_TEST);

}

void display(void)

{

   glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   glutSolidSphere (1.0, 20, 16);

   glFlush ();

}

GL_POSITIONGL_AMBIENTGL_DIFFUSE

GL_SPECULARGL_SPOT_DIRECTIONGL_SPOT_EXPONENT

GL_SPOT_CUTOFFGL_CONSTANT_ATTENUATION

GL_LINEAR_ATTENUATIONGL_CUADRATIC_ATTENUATION

Iluminacion IVOpenGL Programacion

● ResultadosResultados

TransparenciasOpenGL Programacion

● Usando TransparenciasUsando Transparencias– Habilitarlo con glEnableHabilitarlo con glEnable

– Seleccionar funcion para el mezclado de coloresSeleccionar funcion para el mezclado de colores

– El orden de dibujado importaEl orden de dibujado importavoid init(void) {void init(void) {

      glEnable (glEnable (GL_BLENDGL_BLEND););

      glBlendFunc glBlendFunc ((GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHAGL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA););

      glShadeModel (GL_FLAT);glShadeModel (GL_FLAT);

      glClearColor (0.0, 0.0, 0.0, 0.0);glClearColor (0.0, 0.0, 0.0, 0.0);

}}

TransparenciasOpenGL Programacion

● Usando TransparenciasUsando Transparenciasstatic void drawLeftTriangle(void)static void drawLeftTriangle(void)

{{

      /* draw yellow triangle on LHS of screen *//* draw yellow triangle on LHS of screen */

          glBegin (GL_TRIANGLES);glBegin (GL_TRIANGLES);

            glColor4f(1.0, 1.0, 0.0, 0.75);glColor4f(1.0, 1.0, 0.0, 0.75);

            glVertex3f(0.1, 0.9, 0.0);glVertex3f(0.1, 0.9, 0.0);

            glVertex3f(0.1, 0.1, 0.0);glVertex3f(0.1, 0.1, 0.0);

            glVertex3f(0.7, 0.5, 0.0);glVertex3f(0.7, 0.5, 0.0);

      glEnd();glEnd();

}}

Display Lists IOpenGL Programacion

● Mejoran rendimiento cuando se dibuja una misma Mejoran rendimiento cuando se dibuja una misma geometria repetidamentegeometria repetidamente

● Creacion y uso de Display ListsCreacion y uso de Display Listsvoid init (void)    { void init (void)    { 

      geom1 = geom1 = glGenListsglGenLists (1);                                                    (1);                                                   

      glNewListglNewList (geom1,  (geom1, GL_COMPILEGL_COMPILE); ); 

      /* Comandos OpenGL para generar la geometria*/ /* Comandos OpenGL para generar la geometria*/ 

      glEndListglEndList();   ....();   ....

void display (void) {void display (void) {

    ....  ....  

    glCallListglCallList (geom1); (geom1);

GL_COMPILEGL_COMPILE_AND_EXECUTE

Display Lists IIOpenGL Programacion

● Ejecutando Multiples Display ListsEjecutando Multiples Display Listsvoid init (void)    { void init (void)    { 

    GLuint     base;GLuint     base;

      base = base = glGenListsglGenLists (128); (128);

      glListBaseglListBase (base); (base);

      glNewLisglNewListt (base + 'A',  (base + 'A', GL_COMPILEGL_COMPILE); genera_letraA (); ...); genera_letraA (); ...

      glNewListglNewList (base + 'Z',  (base + 'Z', GL_COMPILEGL_COMPILE); genera_letraZ ();); genera_letraZ ();

      glEndListglEndList();   ....();   ....

void display (void) {void display (void) {

    ....  ....  

    glCallListsglCallLists (10, GL_BYTE, (GLbyte*) “HOLA MUNDO”); (10, GL_BYTE, (GLbyte*) “HOLA MUNDO”);

Texturas IOpenGL Programacion

● Creacion de texturasCreacion de texturasGluint     texName;Gluint     texName;

glGenTextures glGenTextures (1, &texName);(1, &texName);

glBindTextureglBindTexture ( (GL_TEXTURE_2DGL_TEXTURE_2D, texName);, texName);

glTexParameteriglTexParameteri((GL_TEXTURE_2DGL_TEXTURE_2D, , GL_TEXTURE_WRAP_SGL_TEXTURE_WRAP_S, , GL_REPEATGL_REPEAT););

glTexParameteriglTexParameteri((GL_TEXTURE_2DGL_TEXTURE_2D, , GL_TEXTURE_WRAP_TGL_TEXTURE_WRAP_T, , GL_REPEATGL_REPEAT););

glTexParameteriglTexParameteri((GL_TEXTURE_2DGL_TEXTURE_2D, , GL_TEXTURE_MAG_FILTERGL_TEXTURE_MAG_FILTER, , GL_NEARESTGL_NEAREST););

glTexParameteriglTexParameteri((GL_TEXTURE_2DGL_TEXTURE_2D, , GL_TEXTURE_MIN_FILTERGL_TEXTURE_MIN_FILTER, , GL_NEARESTGL_NEAREST););

glTexImage2DglTexImage2D((GL_TEXTURE_2DGL_TEXTURE_2D, 0, , 0, GL_RGBAGL_RGBA, checkImageWidth, checkImageHeight, 0, , checkImageWidth, checkImageHeight, 0, GL_RGBAGL_RGBA, , GL_UNSIGNED_BYTEGL_UNSIGNED_BYTE, checkImage);, checkImage);

GL_REPEATGL_CLAMP

Texturas IIOpenGL Programacion

● Mapeando texturasMapeando texturas      glEnable(glEnable(GL_TEXTURE_2DGL_TEXTURE_2D););

      glTexEnvfglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);

      glBindTextureglBindTexture(GL_TEXTURE_2D, texName);(GL_TEXTURE_2D, texName);

      glBegin(GL_QUADS);glBegin(GL_QUADS);

      glTexCoord2fglTexCoord2f(0.0, 0.0); glVertex3f(­2.0, ­1.0, 0.0);(0.0, 0.0); glVertex3f(­2.0, ­1.0, 0.0);

      glTexCoord2fglTexCoord2f(0.0, 1.0); glVertex3f(­2.0, 1.0, 0.0);(0.0, 1.0); glVertex3f(­2.0, 1.0, 0.0);

      glTexCoord2fglTexCoord2f(1.0, 1.0); glVertex3f(0.0, 1.0, 0.0);(1.0, 1.0); glVertex3f(0.0, 1.0, 0.0);

      glTexCoord2fglTexCoord2f(1.0, 0.0); glVertex3f(0.0, ­1.0, 0.0);(1.0, 0.0); glVertex3f(0.0, ­1.0, 0.0);

........

Texturas IIIOpenGL Programacion● Generacion de TexturasGeneracion de Texturas              void glTexImage2D( GLenum target,void glTexImage2D( GLenum target,

                                                    GLint level,GLint level,

                                                    GLint internalFormat,GLint internalFormat,

                                                    GLsizei width,GLsizei width,

                                                    GLsizei height,GLsizei height,

                                                    GLint border,GLint border,

                                                    GLenum format,GLenum format,

                                                    GLenum type,GLenum type,

                                                    const GLvoid *pixels )const GLvoid *pixels )

GL_TEXTURE_2DGL_PROXY_TEXTURE_2D

2m + 2b (en general potencias de 2)

0 o 1

Formato de pixelsRGB, BYTE...

LoD

Texturas IVOpenGL Programacion

● Otras operaciones con texturasOtras operaciones con texturas– glCopyTexImage2D: Obtiene imagen del glCopyTexImage2D: Obtiene imagen del 

FramebufferFramebuffer

– glTexSubImage2D: Sustituye una parte de la texturaglTexSubImage2D: Sustituye una parte de la textura

– Render to Texture, Texturas animadas,...Render to Texture, Texturas animadas,...

● Texturas 1DTexturas 1D– glTexImage1D: Textura de una dimension (linea)glTexImage1D: Textura de una dimension (linea)

Texturas VOpenGL Programacion

● LoD (Level of Detail). Mip MappingLoD (Level of Detail). Mip Mapping– Del latin (Multim im parvo)Del latin (Multim im parvo)

– Original, 1/4, 1/16, 1/64Original, 1/4, 1/16, 1/64

– OpenGL determina que textura utilizar dependiendo OpenGL determina que textura utilizar dependiendo del tamaño del objeto (pixels) en el que se mapeadel tamaño del objeto (pixels) en el que se mapea

● MipMappingMipMapping– Hay que porporcionar todas las texturas, desde la Hay que porporcionar todas las texturas, desde la 

original hasta 1x1 pixelsoriginal hasta 1x1 pixels

Texturas VIOpenGL Programacion● Generando un MipmapGenerando un Mipmap      GLubyte mipmapImage32[32][32][4];GLubyte mipmapImage32[32][32][4];

      ........

      GLubyte mipmapImage1[1][1][4];GLubyte mipmapImage1[1][1][4];

      ........

      glTexImage2D(GL_TEXTURE_2D, glTexImage2D(GL_TEXTURE_2D, 00, GL_RGBA, , GL_RGBA, 32, 3232, 32, 0,, 0,

                                GL_RGBA, GL_UNSIGNED_BYTE, GL_RGBA, GL_UNSIGNED_BYTE, mipmapImage32mipmapImage32););

      glTexImage2D(GL_TEXTURE_2D, glTexImage2D(GL_TEXTURE_2D, 11, GL_RGBA, , GL_RGBA, 16, 1616, 16, 0,, 0,

                                GL_RGBA, GL_UNSIGNED_BYTE, GL_RGBA, GL_UNSIGNED_BYTE, mipmapImage16mipmapImage16););

    ......

      glTexImage2D(GL_TEXTURE_2D, glTexImage2D(GL_TEXTURE_2D, 55, GL_RGBA, , GL_RGBA, 1, 11, 1, 0,, 0,

                                GL_RGBA, GL_UNSIGNED_BYTE, GL_RGBA, GL_UNSIGNED_BYTE, mipmapImage1mipmapImage1););

Texturas VIIOpenGL Programacion

● MipMap RenderMipMap Render      glBindTexture(GL_TEXTURE_2D, texName);glBindTexture(GL_TEXTURE_2D, texName);

      glBegin(GL_QUADS);glBegin(GL_QUADS);

      glTexCoord2f(0.0, 0.0); glVertex3f(­2.0, ­1.0, 0.0);glTexCoord2f(0.0, 0.0); glVertex3f(­2.0, ­1.0, 0.0);

      glTexCoord2f(0.0, 8.0); glVertex3f(­2.0, 1.0, 0.0);glTexCoord2f(0.0, 8.0); glVertex3f(­2.0, 1.0, 0.0);

      glTexCoord2f(8.0, 8.0); glVertex3f(2000.0, 1.0, ­6000.0);glTexCoord2f(8.0, 8.0); glVertex3f(2000.0, 1.0, ­6000.0);

      glTexCoord2f(8.0, 0.0); glVertex3f(2000.0, ­1.0, ­6000.0);glTexCoord2f(8.0, 0.0); glVertex3f(2000.0, ­1.0, ­6000.0);

      glEnd();glEnd();

Texturas VIIIOpenGL Programacion

● Filtrado de TexturasFiltrado de TexturasglTexParameteriglTexParameteri((GL_TEXTURE_2DGL_TEXTURE_2D, , GL_TEXTURE_MAG_FILTERGL_TEXTURE_MAG_FILTER, , GL_NEARESTGL_NEAREST););

glTexParameteriglTexParameteri((GL_TEXTURE_2DGL_TEXTURE_2D, , GL_TEXTURE_MIN_FILTERGL_TEXTURE_MIN_FILTER, , GL_NEARESTGL_NEAREST););      

GL_TEXTURE_MAG_FILTER

GL_NEARESTGL_LINEAR

GL_TEXTURE_MIN_FILTER

GL_NEARESTGL_LINEAR

GL_NEAREST_MIPMAP_NEARESTGL_NEAREST_MIPMAP_LINEARGL_LINEAR_MIPMAP_NEARESTGL_LINEAR_MIPMAP_LINEAR

Otras FuncionalidadesOpenGL Programacion

● Graficos 2DGraficos 2D– Pixels, Bitmaps y Fonts. BitBlitingPixels, Bitmaps y Fonts. BitBliting

● Tessellators y Quadrics (GLUT)Tessellators y Quadrics (GLUT)– OpenGL no puede renderizar OpenGL no puede renderizar 

poligonos concavos rellenospoligonos concavos rellenos

– Tessellation : conversion a Tessellation : conversion a poligonos convexospoligonos convexos

Otras FuncionalidadesOpenGL Programacion

● FramebufferFramebuffer– Color Buffer:Color Buffer:

● Front, Back, Front­left, Front­right, Back­left, Back­right,..Front, Back, Front­left, Front­right, Back­left, Back­right,..● Right/Left depende de la implementacion OpenGLRight/Left depende de la implementacion OpenGL● Debe soportar GL_STEREO o GL_DOUBLEBUFFERDebe soportar GL_STEREO o GL_DOUBLEBUFFER

– Depth BufferDepth Buffer● Ocultacion de CarasOcultacion de Caras

– Stencil BufferStencil Buffer● Enmascarado, contornos de objetos,...Enmascarado, contornos de objetos,...

Otras FuncionalidadesOpenGL Programacion

● FramebufferFramebuffer– Accumulation BufferAccumulation Buffer

● Motion Blur, Depth of Field, etc...Motion Blur, Depth of Field, etc...● En general es muy lentoEn general es muy lento

Otras FuncionalidadesOpenGL Programacion

● Evaluadores y NURBSEvaluadores y NURBS– Evaluadores OpenGL para Evaluadores OpenGL para 

dibujar curvas 2D y 3Ddibujar curvas 2D y 3D

– GLUT soporte para generar GLUT soporte para generar superficies NURBS superficies NURBS (Non­Uniform Rational B­Spline)(Non­Uniform Rational B­Spline)

Otras FuncionalidadesOpenGL Programacion

● Selección y FeedbackSelección y Feedback– Modo selección: Permite seleccionar objetos en la Modo selección: Permite seleccionar objetos en la 

escena a partir de coordenadas 2D (selección con escena a partir de coordenadas 2D (selección con raton)raton)

● Es necesario redibujar toda la escena. En modo selección no Es necesario redibujar toda la escena. En modo selección no se generan pixelsse generan pixels

● Es necesario asignar “nombre” a los objetos seleccionablesEs necesario asignar “nombre” a los objetos seleccionables● Una vez definida el area de interes obtenemos una listaUna vez definida el area de interes obtenemos una lista

de objetos en ella... de objetos en ella... 

– Modo Feedback: Similar a selección pero devuelve las Modo Feedback: Similar a selección pero devuelve las primitivas ejecutadas en el proceso de renderprimitivas ejecutadas en el proceso de render

Otras FuncionalidadesOpenGL Programacion

● Antialias Antialias     glEnable (glEnable (GL_POINT_SMOOTHGL_POINT_SMOOTH); ); 

    glEnable (glEnable (GL_LINE_SMOOTHGL_LINE_SMOOTH););

    glEnable (glEnable (GL_POLYGON_SMOOTHGL_POLYGON_SMOOTH););

    glHint glHint (GL_LINE_SMOOTH, (GL_LINE_SMOOTH, DONT_CAREDONT_CARE););

    glHintglHint (GL_POINT_SMOOTH,  (GL_POINT_SMOOTH, GL_NICESTGL_NICEST););

    glHintglHint  (GL_POLYGON_SMOOTH, (GL_POLYGON_SMOOTH, GL_FASTESTGL_FASTEST););

● Activacion del blending con RGBAActivacion del blending con RGBA      glEnable (GL_BLEND);                                                         glEnable (GL_BLEND);                                                         

      glBlendFunc (GL_SRC_ALPHA, glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHAGL_ONE_MINUS_SRC_ALPHA); ); 

      glBlendFunc (GL_SRC_ALPHA, glBlendFunc (GL_SRC_ALPHA, GL_ONEGL_ONE); ); 

NieblaOpenGL Programacion

● Efecto Niebla Efecto Niebla       glEnable(glEnable(GL_FOGGL_FOG);    {);    {

            GLfloat fogColor[4] = {0.5, 0.5, 0.5, 1.0};GLfloat fogColor[4] = {0.5, 0.5, 0.5, 1.0};

            fogMode = fogMode = GL_EXPGL_EXP;;

            glFogiglFogi ( (GL_FOG_MODEGL_FOG_MODE, fogMode);, fogMode);

            glFogfvglFogfv ( (GL_FOG_COLORGL_FOG_COLOR, fogColor);, fogColor);

            glFogfglFogf ( (GL_FOG_DENSITYGL_FOG_DENSITY, 0.35);, 0.35);

            glHint (glHint (GL_FOG_HINTGL_FOG_HINT, GL_DONT_CARE);, GL_DONT_CARE);

            glFogfglFogf ( (GL_FOG_STARTGL_FOG_START, 1.0);, 1.0);

            glFogfglFogf ( (GL_FOG_ENDGL_FOG_END, 5.0);, 5.0);

      }}

      glClearColor(0.5, 0.5, 0.5, 1.0);  /* fog color */glClearColor(0.5, 0.5, 0.5, 1.0);  /* fog color */

Sistema Graficos TMM: Tecnoloxia Multimedia 2006