Primitivas en OpenGL

mat-610

Funciones de lneas en OpenGL

Default: slida, blanca. GL_LINES, GL_LINE_STRIP, GL_LINE_LOOP. Pares de vrtices.
p3 p1

glBegin( GL_LINES ); glVertex2iv (p1); glVertex2iv (p2); glVertex2iv (p3); glVertex2iv (p4); glVertex2iv (p5); glEnd();
p2

p4

p3

glBegin( GL_LINE_STRIP ); glVertex2iv (p1); glVertex2iv (p2); glVertex2iv (p3); glVertex2iv (p4); glVertex2iv (p5); glEnd();

p1

p5

p4

p2

p3

p1

glBegin( GL_LINE_LOOP ); glVertex2iv (p1); glVertex2iv (p2); glVertex2iv (p3); glVertex2iv (p4); glVertex2iv (p5); glEnd();

p5

p4

Puntos, lneas y polgonos

Todas las primitivas geomtricas se describen en trminos de sus vrtices. punto : un solo pixel. Las operaciones con puntos suponen puntos 3d. lnea : segmento de recta denido por sus puntos extremos. polgono : reas encerradas por cclos de segmentos de recta. polgonos simples (no se intersectan a si mismos), polgonos convexos.

Especicando vrtices
void glVertex{234}{sifd}[v]( TYPE coords );

Se pueden especicar desde 2 coordenadas (x,y) hasta 4 (x,y,z,w). Si no se especica z=0 y w=1. Las llamadas a glVertex*() solo son efectivas cuando se escriben entre el par glBegin() y glEnd().
glVertex2s(2,3); glVertex3d( 0.0, 0.0, 3.1415926535898 ); glVertex4f( 2.3, 1.0, -2.2, 2.0 ); GLdouble dvect[3] = {5.0, 9.0, 1992.0 }; glVertex3fv( dvect );

Primitivas geomtricas en OpenGL

glColor3f( 1.0, 0.0, 1.0 ); glBegin( GL_POLYGON ); glVertex2f( 0.0, 0.0 ); glVertex2f( 0.0, 3.0 ); glVertex2f( 4.0, 3.0 ); glVertex2f( 6.0, 1.5 ); glVertex2f( 4.0, 0.0 ); glEnd();

void glBegin( GLenum mode ); valor GL_POINTS GL_LINES GL_LINE_STRIP GL_LINE_LOOP GL_TRIANGLES GL_TRIANGLE_STRIP GL_TRIANGLE_FAN GL_QUADS GL_QUAD_STRIP GL_POLYGON

Primitivas geomtricas en OpenGL

v1 v0 v1 v2 v4 v2 v0 v4 v3 v7 v3 v6 GL_POINTS GL_LINES v5

v0 v2 v3 v4 GL_LINE_STRIP v1 v1 v2

v0 v4 v5 v0 v2

v5

v3 v3 GL_LINE_LOOP v1 GL_TRIANGLES

v4

v0

v2

v4

v4

v3 v2

v7

v6

v0 v 2

v4

v6 v1

v0 v4 v2

v5 v1 v3 GL_TRIANGLE_STRIP

v0 v1 GL_TRIANGLE_FAN v0

v3

v2 v4 v1 GL_QUADS v5 v1 v5 v3 GL_QUAD_STRIP

v7 GL_POLYGON

v3

Limpiar la ventana
La memoria de despliegue almacena generalmente datos antes de dibujar. Por qu no solo dibujar un rectngulo del tamao y color de la imgen? porque el comando de limpieza est optimizado, la forma del rea de despliegue puede ser diferente a un rectngulo.

glClearColor( 0.0f, 0.0f, 0.0f, 1.0f ); glClear( GL_COLOR_BUFFER_BIT );

OpenGL & Qt
#ifndef GLWIDGET_H #define GLWIDGET_H #include <QGLWidget> class GLWidget : public QGLWidget { Q_OBJECT public: GLWidget( QWidget *parent=0 ); ~GLWidget(); protected: void initializeGL(); void paintGL(); }; #endif

void GLWidget :: initializeGL() { glClearColor( 0.0f, 0.0f, 0.0f, 1.0f ); // initialize other states ... } void GLWidget :: paintGL() { glClear( GL_COLOR_BUFFER_BIT ); // draw primitives ... }

glClearDepth(1.0); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

Documentacin OpenGL

void glClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );

Sets the current clearing color for use in clearing color buffers in RGBA mode. The red, green, blue and alpha values are clamped if necessary to the range [0,1]. The default clearing color is (0, 0, 0, 0), which is black.

Especicar un color en OpenGL

set_current_color( red ); draw_object( A ); draw_object( B ); set_current_color( green ); set_current_color( blue ); draw_object( C );

glColor3f( glColor3f( glColor3f( glColor3f( glColor3f( glColor3f( glColor3f( glColor3f(

0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0,

0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0,

0.0 0.0 0.0 1.0 0.0 1.0 1.0 1.0

); ); ); ); ); ); ); );

// // // // // // // //

black red green blue yellow magenta cyan white

OpenGL como mquina de estados

void glEnable( GLenum capability ); void glDisable( GLenum capability ); ej. GL_BLEND, GL_DEPTH_TEST, GL_FOG, GL_LIGHTING...

GLboolean glIsEnabled( GLenum capability ); regresa GL_TRUE o GL_FALSE.

void void void void void

glGetBooleanv( GLenum pname, GLBoolean *params ); glGetIntegerv( GLenum pname, GLint *params ); glGetFloatv( GLenum pname, GLfloat *params ); glGetDoublev( GLenum pname, GLdouble *params ); glGetPointerv( GLenum pname, GLvoid **params );

Tamao del punto (default es 1.0)

void glPointSize( GLfloat size );

Ancho de la lnea (default es 1.0)

void glLineWidth( GLfloat width );

Patrn de lneas punteadas

void glLineStipple( GLint factor, GLushort pattern );
glLineStipple( 1, 0x00FF ); glEnable( GL_LINE_STIPPLE );
PATTERN 0x3F07 0x00FF 0x00FF 0x0C0F 0x0C0F FACTOR 1 1 2 1 3 13

0 0 1 1 1 1 1 1 0 0 0 0 0 1 1 1

0x3F07

Ejemplo libro rojo 2-5 (en la pgina web)

Polgonos como puntos, contornos o slidos

Un polgono tiene dos lados, frente y atrs: puede dibujarse diferente dependiendo qu lado mira el usuario. Por default se dibujan igual.

void glPolygonMode( GLenum face, GLenum mode ); face: GL_FRONT_AND_BACK, GL_FRONT, GL_BACK mode: GL_POINT, GL_LINE, GL_FILL glPolygonMode( GL_FRONT, GL_FILL ); glPolygonMode( GL_BACK, GL_LINE );

Polgonos en OpenGL
Por convencin los polgonos cuyos vrtices aparecen en orden contrario a las manecillas del reloj (CCW) en la pantalla se dicen orientados hacia el frente (front-facing). La mayora de los slidos pueden representarse con polgonos de orientacin consistente (orientable manifolds) - esfera, toros, teteras, conejos, etc... no orientados - botella de klein, banda de Mbius...

Polgonos en OpenGL
void glFrontFace( GLenum mode ); mode: GL_CCW, GL_CW.

Culling - operacin que evita desplegar ciertas caras del polgono, las de adentro o las de afuera, dependiendo de la posicin de la cmara.

void glCullFace( GLenum mode ); mode: GL_FRONT, GL_BACK, GL_FRONT_AND_BACK glEnable( GL_CULL_FACE ); glDisable( GL_CULL_FACE );

Polgonos en OpenGL
Un polgono puede dibujarse con un patrn de 32x32 bits. El argumento es una mscara de 0s y 1s. Cuando aparece 1 se dibuja el pixel, si es 0 no dibuja.

void glPolygonStipple( GLubyte * mask ); glEnable( GL_POLYGON_STIPPLE ); glDisable( GL_POLYGON_STIPPLE );

0x06 0x03 0x00 0x00

128

64

32

16

* para cada byte el bit ms signicativo va primero

Ejemplo libro rojo 2-6 (en la pgina web)

19

Polgonos no-convexos en OpenGL

Se dividen los polgonos no-convexos en partes convexas.
v2

v1 v0

void glEdgeFlag( GLboolean flag );

glPolygonMode( GL_FRONT_AND_BACK, GL_LINE ); glBegin( GL_POLYGON ); glEdgeFlag( GL_TRUE ); glVertex3fv( v0 ); glEdgeFlag( GL_FALSE ); glVertex3fv( v1 ); glEdgeFlag( GL_TRUE ); glVertex3fv( v2 ); glEnd();

Vectores normales
Vector que apunta en la direccin perpendicular a una supercie (plana). Si la supercie es curva la direccin normal puede ser diferente en cada punto. En OpenGL se puede especicar una normal por polgono o por vrtice. Los vectores normales a un objeto denen la orientacin de su supercie, en particular relativamente a las fuentes de luz. (captulo 5) se usan para determinar cunta luz recibe en cada vrtice. (apndice E)
glBegin( GL_POLYGON ); glNormal3fv( n0 ); glVertex3fv( v0 ); glNormal3fv( n1 ); glVertex3fv( v1 ); glNormal3fv( n2 ); glVertex3fv( v2 ); glNormal3fv( n3 ); glVertex3fv( v3 ); glEnd();

glEnable( GL_NORMALIZE );