Primitivas en OpenGL

mat-610
Primitivas geomtricas en OpenGL
GL_POINTS
v
0
v
1
v
2
v
3
v
4
GL_LINES
v
0
v
1
v
2
v
3
v
4
v
5 v
6
v
7
GL_LINE_STRIP
v
0
v
1
v
2
v
3
v
4
GL_LINE_LOOP
v
0
v
1
v
2
v
3
v
4
v
5
GL_TRIANGLES
v
1
v
0
v
2
v
3 v
4
v
5
GL_TRIANGLE_STRIP
v
0
v
1
v
2
v
3
v
4
v
5
GL_TRIANGLE_FAN
v
0
v
1
v
2
v
3 v
4
GL_QUADS
v
0
v
1
v
2
v
3
v
4
v
5
v
6
v
7
GL_QUAD_STRIP
v
0
v
1
v
2
v
3
v
4
v
5
v
6
v
7
GL_POLYGON
v
0
v
1
v
2
v
3
v
4
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 );
Limpiar la ventana
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.
Especificar 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( 0.0, 0.0, 0.0 ); // black
glColor3f( 1.0, 0.0, 0.0 ); // red
glColor3f( 0.0, 1.0, 0.0 ); // green
glColor3f( 0.0, 0.0, 1.0 ); // blue
glColor3f( 1.0, 1.0, 0.0 ); // yellow
glColor3f( 1.0, 0.0, 1.0 ); // magenta
glColor3f( 0.0, 1.0, 1.0 ); // cyan
glColor3f( 1.0, 1.0, 1.0 ); // 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 glGetBooleanv( GLenum pname, GLBoolean *params );
void glGetIntegerv( GLenum pname, GLint *params );
void glGetFloatv( GLenum pname, GLfloat *params );
void glGetDoublev( GLenum pname, GLdouble *params );
void glGetPointerv( GLenum pname, GLvoid **params );
7
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 );
1 1 1 0 0 0 0 0 1 1 1 1 1 1 0 0 0x3F07
Tamao del punto (default es 1.0)
PATTERN FACTOR
0x3F07 1
0x00FF 1
0x00FF 2
0x0C0F 1
0x0C0F 3
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
Culling - operacin que evita desplegar ciertas caras del polgono, las de
adentro o las de afuera, dependiendo de la posicin de la cmara.
void glFrontFace( GLenum mode );
mode: GL_CCW, GL_CW.
void glCullFace( GLenum mode );
mode: GL_FRONT, GL_BACK, GL_FRONT_AND_BACK
glEnable( GL_CULL_FACE );
glDisable( GL_CULL_FACE );
Polgonos en OpenGL
void glPolygonStipple( GLubyte * mask );
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.
glEnable( GL_POLYGON_STIPPLE );
glDisable( GL_POLYGON_STIPPLE );
1 2 4 8 16 32 64 128
0x00
0x00
0x03
0x06
* para cada byte el bit ms
signicativo va primero
13
Ejemplo libro rojo 2-6 (en
la pgina web)
Polgonos no-convexos en OpenGL
Se dividen los polgonos no-convexos en partes convexas.
void glEdgeFlag( GLboolean flag );
v
0
v
1
v
2
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 );
Algunos tutoriales
http://user.xmission.com/~nate/tutors.html
int
main(int argc, char** argv)
{
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(512+GAP*3, 512+GAP*3);
glutInitWindowPosition(50, 50);
glutInit(&argc, argv);

window = glutCreateWindow("Fog");
glutReshapeFunc(main_reshape);
glutDisplayFunc(main_display);
glutKeyboardFunc(main_keyboard);

world = glutCreateSubWindow(window, GAP, GAP, 256, 256);
glutReshapeFunc(world_reshape);
glutDisplayFunc(world_display);
glutKeyboardFunc(main_keyboard);

screen = glutCreateSubWindow(window, GAP+256+GAP, GAP, 256, 256);
glutReshapeFunc(screen_reshape);
glutDisplayFunc(screen_display);
glutKeyboardFunc(main_keyboard);
glutCreateMenu(screen_menu);
glutAddMenuEntry("Models", 0);
glutAddMenuEntry("", 0);
glutAddMenuEntry("Soccerball", 's');
glutAddMenuEntry("Al Capone", 'a');
glutAddMenuEntry("F-16 Jet", 'j');
glutAddMenuEntry("Dolphins", 'd');
glutAddMenuEntry("Flowers", 'f');
glutAddMenuEntry("Porsche", 'p');
glutAddMenuEntry("Rose", 'r');
glutAttachMenu(GLUT_RIGHT_BUTTON);


command = glutCreateSubWindow(window, GAP+256+GAP, GAP+256+GAP, 256, 256);
glutReshapeFunc(command_reshape);
glutDisplayFunc(command_display);
glutMotionFunc(command_motion);
glutMouseFunc(command_mouse);
glutKeyboardFunc(main_keyboard);
glutCreateMenu(command_menu);
glutAddMenuEntry("Fog", 0);
glutAddMenuEntry("", 0);
glutAddMenuEntry("[l] GL_LINEAR", 'l');
glutAddMenuEntry("[e] GL_EXP", 'e');
glutAddMenuEntry("[x] GL_EXP2", 'x');
glutAddMenuEntry("[c] Clear color toggle", 'c');
glutAddMenuEntry("[r] Reset parameters", 'r');
glutAddMenuEntry("", 0);
glutAddMenuEntry("Quit", 27);
glutAttachMenu(GLUT_RIGHT_BUTTON);

redisplay_all();

glutMainLoop();

return 0;
}
Algoritmos de conversin de
primitivas geomtricas
(raster conversion)
mat-610
Algoritmos bsicos
Un software de raster aproxima los primitivos descritos (lneas, puntos,
polgonos) en una malla Cartesiana, con pixels de la intensidad de gris o color
apropiado.
Los pixels se almacenan como un bitmap o pixmap en memoria del CPU o en
un frame buffer.
Examinaremos algoritmos en trminos de una grilla Cartesiana de enteros,
pero se pueden extender a algoritmos con punto otante o a 3 dimensiones.
Pipeline de salida
Cada primitiva se convierte en pixels que se escriben en el cuadro que
corresponde con los atributos especicados.
La primitiva es ajustada o cortada (clipped) al rectngulo especicado: los
pixels fuera del rectngulo no se despliegan.
cortar la primitiva antes de ser dibujada calculando analticamente sus
intersecciones con el rectngulo.
ventajas?
solo hay que trabajar con la primitiva cortada, la original puede ser
mucho ms grande.
para cortar se usan principalmente lneas, rectngulos y polgonos.
Conversin de segmentos de recta
A = (x
a
, y
a
)
B = (x
b
, y
b
)
A
B
P
dx
dy
dx = x
b
x
a
dy = y
b
y
a
m =
dy
dx
F(x, y) = 0, con F(x, y) = dy(x x
a
) dx(y y
a
)
Punto en una recta:
Punto a la izquierda o a la derecha de la recta:
F(x
m
, y
m
) < 0, izquierda del segmento [A, B] dirigido de A a B
F(x
m
, y
m
) > 0, derecha del segmento [A, B] dirigido de A a B
Conversin de segmentos de recta
A
B
P
dx
dy
dx = x
b
x
a
dy = y
b
y
a
m =
dy
dx
F(x, y) = 0, con F(x, y) = dy(x x
a
) dx(y y
a
)
De donde obtenemos:
Sea un punto P = (x
p
,y
p
) de la recta R y
que tenga por abcisa:
x
p
= x
a
+
x
Sustituyendo para vericar en la ecuacin de arriba
tenemos:
0 = F(x
p
, y
p
)
= d
y
(x
p
x
a
) d
x
(y
p
y
a
)
= d
y
(x
a
+
x
x
a
) d
x
(y
p
y
a
)
dy.x = dx(y
p
y
a
)
y
p
= y
a
+
dy
dx
.x
y
p
= y
a
+mx
Conversin de segmentos de recta
Los objetos geomtricos en una imgen son aproximaciones discretas de
ideales continuos.
Se necesitan mtodos ecaces para pasar de los objetos ideales a la
discretizacin con la que ser representada la imgen.
Suponemos contar con una primitiva:
void QImage::setPixel ( int x, int y, uint index_or_rgb )
que permite dibujar el pixel (x,y) del color rgb y por el momento queremos
dibujar solamente segmentos de recta.
Nos limitaremos a dibujar segmentos de grosor 1.
Tomaremos solo pendientes entre -1 y 1, las dems las calcularemos por
simetra.
Conversin de segmentos de recta
La secuencia de pixels debe estar lo ms cerca
posible de la lnea ideal
Consideramos una lnea de 1 pixel de ancho:
si la pendiente est entre -1 y 1, 1 pixel debe
estar iluminado en cada columna.
si la pendiente est fuera de este rango 1
pixel debe estar iluminado en cada rengln.
todas las lneas deben dibujarse con brillo
constante, independientemente de su largo y
orientacin y lo ms rpido posible.
preveer otros anchos, tipos de pluma, tipo de
puntos extremos, etc.