View
213
Download
0
Category
Preview:
Citation preview
Dar varias propiedades a los Primitivos de OpenGL
Curso: Graficación
Prof. Gueorgi Khatchatourov
Contenido
• Cómo ver un polígono?• Con qué color ver un objeto?• Como llenar Polígonos, o re-visitando
“Stippling” (ver “Other Primitives” de Chapter III “Drawing in Space” de “OpenGL SuperBible”)
• Cómo tratar los polígonos no convexos• Cómo tratar los polígonos no planos• Usar “Stencil Buffer” (plantilla para pintar)• Usar “Scissors” (tijeras)
Regresar al indice Cómo ver un polígono?(I de II)
• Ver lo interior de un polígono? Ver ambos lados de un polígono? Ver un polígono desde ambos lados? Ver los bordes de un polígono ?
• -----------------------------------------------------------------------------------------------------------------------
• Polygons as Points, Outlines, or Solids• A polygon has two sides - front and back - and might be rendered differently depending on which
side is facing the viewer. By default, both front and back faces are drawn in the same way. To change this, or to draw only outlines or vertices, use glPolygonMode().
• void glPolygonMode(GLenum face, GLenum mode);
_ Controls the drawing mode for a polygon's front and back faces. The parameter face can be GL_FRONT_AND_BACK, GL_FRONT, or GL_BACK; mode can be GL_POINT, GL_LINE, or GL_FILL to indicate whether the polygon should be drawn as points, outlined, or filled.
• By default, both the front and back faces are drawn filled.
• For example, you can have the front faces filled and the back faces outlined with two calls to this routine:
glPolygonMode(GL_FRONT, GL_FILL);glPolygonMode(GL_BACK, GL_LINE);
Regresar al indice Cómo ver un polígono?(II de II):
Ver ambos lados de un polígono? Los controles para cambiar manera de ver diferentes lados de un
polígono son:
– Prender/apagar eliminación de las superficies ocultas () glCullFace
void glCullFace(GLenum mode);Indica cuales polígonos deben ser eliminados (culled) antes que se convierten en
las coordenadas de pantalla. El mode es uno de GL_FRONT, GL_BACK, o GL_FRONT_AND_BACK para indicar el lado anverso, reverso o todos los polígonos.
To take effect, culling must be enabled using glEnable() with GL_CULL_FACE; it can be disabled with glDisable() and the same argument.
– Cambia el sentido de los lados frontales y traseras glFrontFace(GL_CW);
Regresar al índice Con qué color ver un objeto?
Con que color ver lo interior de un objeto? Cómo el color interior de un polígono depende de los vértices? Cómo lo depende de propiedades de luz, de material?
-----------------------------------------------------------------------------
• Mecanísmos de formación de color de un pixel
ir al índice Cómo tratar los polígonos no convexos (I de II)
• Figure 2-12 : Subdividing a Nonconvex Polygon
you can manually control the setting of the edge flag with the commandglEdgeFlag*(). It is used between glBegin() and glEnd() pairs, and it affects all the vertices specified after it until the next glEdgeFlag() call is made. It applies only to vertices specified for polygons, triangles, and quads, not to those specified for strips of triangles or quads.
void glEdgeFlag(GLboolean flag);void glEdgeFlagv(const GLboolean *flag);Indicates whether a vertex should be considered as initializing a boundary edge of a polygon. If flag is GL_TRUE, the edge flag is set to TRUE (the default), and any vertices created are considered to precede boundary edges until this function is called again with flag being GL_FALSE.
ir al índice Cómo tratar los polígonos no convexos (II de II)
Example 2-7 draws the outline shown in Figure 2-13. Figure 2-13 : Outlined Polygon Drawn Using Edge Flags
Example 2-7 : Marking Polygon Boundary Edges
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();
Cómo tratar los polígonos no planos
Regresar al índice Usar “Stencil Buffer” (plantilla para pintar)
Frequently, we want to mask out an irregularly shaped area using a stencil pattern. In the real world, a stencil is a flat piece of cardboard or other material that has a pattern cut out of it. Painters use the stencil to apply paint to a surface using the pattern in the stencil. Figure shows how this process works.
The stencil test takes place only if there is a stencil buffer. (If there is no stencil buffer, the stencil test always passes.) Stenciling applies a test that compares a reference value with the value stored at a pixel in the stencil buffer. Depending on the result of the test, the value in the stencil buffer is modified.
El stencil test modifica contenido
del pixel en stencil buffer basandose
en el resultado de una comparición del
valor de referencia con el valor en el stencil buffer
Regresar al índice Usar “Stencil Buffer” (II) ir al inicio del stencil buffer
• void init (void)
{ …. glClearStencil(0x0);/*specifica el valor del
vacio para el
"stencil buffer"*/
glEnable(GL_STENCIL_TEST);
}
Ir a lamina anterior Usar “Stencil Buffer” (III):lógica del uso ir al inicio del stencil buffer
• glStencilFunc ( // establece la función y el valor de referencia para “stencil test”
GLenum func, // especifica tipo de comparición para “stencil test”
GLint ref, // valor de referencia;
GLuint mask // máscara. );
Por ejemplo, si
func=GL_EQUAL Entonces, el pixel pasa satisfactoriamente la prueba (stencil test)
siempre y cuando se cumple(ref&mask)=(stencil&mask)
}
Regresar al índice Usar “Stencil Buffer” (IV) ir al inicio del stencil buffer
• void display(void){ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* draw blue sphere where the stencil is 1 */ glStencilFunc (GL_EQUAL, 0x1, 0x1 ); //Ver un ejemplo de lógica de uso de los parametros
glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP); //define la acción del stencil test glCallList (BLUEMAT); glutSolidSphere (0.5, 15, 15);
/* draw the tori where the stencil is not 1 */ glStencilFunc (GL_NOTEQUAL, 0x1, 0x1); glPushMatrix(); glRotatef (45.0, 0.0, 0.0, 1.0); glRotatef (45.0, 0.0, 1.0, 0.0); glCallList (YELLOWMAT); glutSolidTorus (0.275, 0.85, 15, 15); glPushMatrix(); glRotatef (90.0, 1.0, 0.0, 0.0); glutSolidTorus (0.275, 0.85, 15, 15); glPopMatrix(); glPopMatrix();}
Regresar al índice Usar “Stencil Buffer” (V) ir al inicio del stencil buffer
void reshape(int w, int h){….
glMatrixMode(GL_MODELVIEW); glLoadIdentity();
glClear(GL_STENCIL_BUFFER_BIT); glStencilFunc (GL_ALWAYS, 0x1, 0x1); glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE); glBegin(GL_QUADS); glVertex2f (-1.0, 0.0); glVertex2f (0.0, 1.0); glVertex2f (1.0, 0.0); glVertex2f (0.0, -1.0); glEnd();
glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(45.0, (GLfloat) w/(GLfloat) h, 3.0, 7.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(0.0, 0.0, -5.0);
}
ir al indice de la presentacion Usar “Scissors” (tijeras) (I de III)
• One way to improve rendering performance is to update only the portion of the screen that has changed. You may also need to restrict OpenGL rendering to a smaller rectangular region inside the window. OpenGL allows you to specify a scissor rectangle within your window where rendering can take place. By default, the scissor rectangle is the size of the window, and no scissor test takes place. You turn on the scissor test with:
•glEnable(GL_SCISSOR_TEST);
• You can turn off the scissor test again with the corresponding glDisable function call.
ir al indice de la presentacion Usar “Scissors” (tijeras) (II de III)
• Listing 3.13. Using the Scissor Box to Render a Series of Rectangles
void RenderScene(void) { // Clear blue window
glClearColor(0.0f, 0.0f, 1.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT);
// Now set scissor to smaller red sub region glClearColor(1.0f, 0.0f, 0.0f, 0.0f); glScissor(100, 100, 600, 400); glEnable(GL_SCISSOR_TEST); glClear(GL_COLOR_BUFFER_BIT);
// Finally, an even smaller green rectangle glClearColor(0.0f, 1.0f, 0.0f, 0.0f); glScissor(200, 200, 400, 200); glClear(GL_COLOR_BUFFER_BIT);
// Turn scissor back off for next render glDisable(GL_SCISSOR_TEST); glutSwapBuffers();
}
ir al indice de la presentacion Usar “Scissors” (tijeras): salida del programa (III de
III)
Regresar a Cómo ver un polígono Orientación de polígonos (I de II)
• OpenGL, by default, considers polygons that have counterclockwise winding to be front facing. This means that the triangle on the left in Figure 3.15 shows the front of the triangle, and the one on the right shows the back side of the triangle.
Regresar a “Cómo ver un polígono” Orientación de polígonos (II de II) regresar a I de II
• you will often want to give the front and back of a polygon different physical characteristics. You can hide the back of a polygon altogether or give it a different color and reflective property (see SuperBibliaOPenGL Chapter 5, "Color, Materials, and Lighting: The Basics"). It's important to keep the winding of all polygons in a scene consistent, using front-facing polygons to draw the outside surface of any solid objects.
• If you need to reverse the default behavior of OpenGL, you can do so by calling the following function: glFrontFace(GL_CW);
• The GL_CW parameter tells OpenGL that clockwise-wound polygons are to be considered front facing. To change back to counterclockwise winding for the front face, use GL_CCW.
ir al indice de la presentacion Mecanísmos de formación de color de un pixel ir al Con
que color…
• Limpiar el buffer de color y dar un color para todos los píxeles desocupados
• Lógica de coloración de OpenGL Color solido (GL_FLAT) o interpolado (GL_SMOOTH)
• Los factores geométricos y físicos que influyen a la percepción de luz y generación del color final de un píxel
ir al indice de la presentacion Mecanísmos de formación de color
de un pixel: Limpiar el buffer de color y dar un
color para los pixeles desocupados ir al indice de
mecanísmos de coloracion
// limpia el buffer de color
• glClear(GL_COLOR_BUFFER_BIT);
// dar color a los pixeles desocupados• glClearColor (…);
ir al indice de la presentacion Mecanísmos de formación de color
de un pixel: Lógica de coloración de OpenGLir al indice de mecanísmos de coloracion
Podemos considerar la coloración de un objeto como dar una pintura al objeto sin tomar en cuenta cómo lo se verá en una posición especifica respecto a una camara, o de que material se ha hecho o cuanto y cuales luces se tienen en el entorno.
En este sentido hay dos opciones (dos modelos de “SHADING”) de pintura: • con un color sólido (GL_FLAT) • con lo interpolado (GL_SMOOTH)-------------------------------------------------------------------------------------------------------In general, an OpenGL programmer first sets the color or coloring scheme and then draws the objects. Until the color
or coloring scheme is changed, all objects are drawn in that color or using that coloring scheme. This method helps OpenGL achieve higher drawing performance than would result if it didn't keep track of the current color.
For example, the pseudocode
set_current_color(red);draw_object(A);draw_object(B);set_current_color(green);set_current_color(blue);draw_object(C);
draws objects A and B in red, and object C in blue. The command on the fourth line that sets the current color to green is wasted.
ir al indice Lógica de coloración de OpenGL (II de ) : Color solido o interpolado:
lamina II.1: Color solido (GL_FLAT) ir al
indice de mecanísmos de coloracion
Por omisión se supone que el modelo de coloración es como después del comando
glShadeModel (GL_FLAT);
glColor3f (1.0, 0.0, 0.0); /* the current RGB color is red: */
/* full red, no green, no blue. */ glBegin (GL_POINTS); glVertex3fv (point_array); glEnd ();
ir al indice Lógica de coloración de OpenGL (II de ) : Color solido o interpolado:
lamina II.2: Color interpolado (GL_SMOOTH); ir al indice de mecanísmos de coloracion
• #include <GL/glut.h>void init(void){ glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_SMOOTH);}void display(void){ glClear (GL_COLOR_BUFFER_BIT);
glBegin (GL_TRIANGLES);glColor3f (1.0, 0.0, 0.0);glVertex2f (5.0, 5.0);glColor3f (0.0, 1.0, 0.0);glVertex2f (25.0, 5.0);glColor3f (0.0, 0.0, 1.0);glVertex2f (5.0, 25.0);
glEnd();glFlush ();
}
ir al indice Lógica de coloración de OpenGL (II de ) : Color solido o interpolado:
lamina II.2': Color interpolado (GL_SMOOTH); ir al indice de mecanísmos de coloracion
void reshape (int w, int h){ glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);glLoadIdentity ();if (w <= h)gluOrtho2D (0.0, 30.0, 0.0, 30.0*(GLfloat) h/(GLfloat) w);elsegluOrtho2D (0.0, 30.0*(GLfloat) w/(GLfloat) h, 0.0, 30.0);glMatrixMode(GL_MODELVIEW);
}int main(int argc, char** argv){ glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);glutInitWindowSize (500, 500);glutInitWindowPosition (100, 100);glutCreateWindow (argv[0]);init ();glutDisplayFunc(display);glutReshapeFunc(reshape);glutMainLoop();return 0;
}
ir al índice Los factores geométricosgeométricos y físicos que influyen a la percepción de luz y la generación del
color final de un píxel ir al índice de mecanísmos de coloracion
• Los factores geometricos incluyen posicion y orientacion espacial del objeto y de la cámara, posición(es) del(as) fuentes de luz. – Para mejorar rendiminto, tomando en cuenta esos factores, el
paradigma de OpenGL supone procesamiento de color final no para los puntos individuales, sino para polígonos enteros. En su vez, para evitar varios efectos de mal interpretación, cómo los polígonos se usan los triángulostriángulos a los cuales previamente se calculan y se adjuntan vectores normalesvectores normales
• Los factores físicos incluyen color del objeto, propiedades de reflexión del material, propiedades (de transparencia y de iluminación) del medio ambiente
Regla I de Construcción de Polígonos regresar a “factores
geométricosgeométricos y físicos que influyen…” When you are using many polygons to construct a complex surface, you need
to remember two important rules.• The first rule is that all polygons must be planar. That is, all the vertices of
the polygon must lie in a single plane, as illustrated in Figure 3.31. The polygon cannot twist or bend in space.
• Figure 3.31. Planar versus nonplanar polygons.
Regla II de Construcción de Polígonos regresar a “factores geométricosgeométricos y físicos que influyen…”
• The second rule of polygon construction is that the polygon's edges must not intersect, and the polygon must be convex. If any given line enters and leaves the polygon more than once, the polygon is not convex. Figure 3.32 gives examples of good and bad polygons.
• Figure 3.32. Some valid and invalid primitive polygons.
Regresar al índice Usar “Stencil Buffer” (IV’): la acción del stencil test
ir atras
• void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass
);• The value of any of fail, zfail, and zpass can be GL_KEEP,
GL_ZERO, GL_REPLACE, GL_INCR, GL_DECR, or GL_INVERT.
• The fail function is applied if the fragment fails the stencil test; if it passes, then zfail is applied if the depth test fails and zpass if the depth test passes, or if no depth test is performed.
• By default, all three stencil operations are GL_KEEP.
Recommended