Este documento describe las primitivas básicas de dibujo en 3D en OpenGL, incluyendo puntos, líneas, triángulos, cuadriláteros y polígonos generales. Explica cómo dibujar estas primitivas, ajustar sus propiedades como el tamaño y grosor, y cómo crear mallas para rellenar superficies. También cubre temas como la visualización de caras frontales y posteriores, modos de dibujo y reglas para los polígonos.

1. Primitivas Básicas

2. Dibujo en 3D
• Las librerías gráficas antiguas permiten trabajar con puntos 2D (pixels)
• OpenGL no trabaja con coordenadas de pantalla, sino con coordenadas
posicionales dentro del volumen de visualización
• El trasladar toda la escena 3D a la pantalla se realiza automáticamente
x
y
z
glOrtho(-100,100,-100,100,100,-100)
(0,100,0)
(100,0,0)
(0,-100,0)
(-100,0,0)

3. Dibujo de puntos
glBegin(GL_POINTS);
glVertex3s (0, 0, 50);
glVertex2f (-50.0, 50.0);
glEnd();
x
y
z
(-50,50,0)
(0,0,50)

4. Ajuste del tamaño del punto
• El tamaño por defecto de un punto es 1 pixel
• Podemos cambiarlo usando:
void glPointSize (Glfloat tamaño)
• Para conocer qué tamaños soporta nuestra distribución:
Glfloat dimen[2]; // almacena el rango de tamaños
Glfloat paso; // almacena los incrementos de tamaño
glGetFloatv(GL_POINT_SIZE_GRANULARITY, &paso);
glGetFloatv(GL_POINT_SIZE_RANGE, dimen);
• Para mejorar la calidad de los puntos:
void glEnable (GL_POINT_SMOOTH)

5. Dibujo de líneas sueltas
glBegin(GL_LINES);
glVertex3s (0, 0, 50);
glVertex2f (-50.0, 50.0);
glVertex3s (0, 100, 0);
glVertex3s (-100, 100, -100);
glEnd();
x
y
z
(-50,50,0)
(0,0,50)
(0,100,0)
(-100,100,-100)

6. Dibujo de polilíneas
glBegin(GL_LINES_STRIP);
glVertex3s (0, 0, 50);
glVertex2f (-50.0, 50.0);
glVertex3s (0, 100, 0);
glVertex3s (-100, 100, -100);
glEnd();
x
y
z
(-50,50,0)
(0,0,50)
(0,100,0)
(-100,100,-100)
• Para cerrar la polilínea:
glBegin(GL_LINE_LOOP);
...
glEnd();

7. Ajuste del grosor de línea
• El grosor por defecto es 1 pixel
• Podemos cambiarlo usando:
void glLineWidth (Glfloat ancho)
• Para conocer qué tamaños soporta nuestra distribución:
Glfloat dimen[2]; // almacena el rango de anchos posibles
Glfloat paso; // almacena los incrementos de ancho
glGetFloatv(GL_LINE_WIDTH_GRANULARITY, &paso);
glGetFloatv(GL_LINE_WIDTH_RANGE, dimen);

8. Patrones de líneas
• Para dibujar líneas discontinuas primero hay que activar el modo:
void glEnable (GL_LINE_STIPPLE)
• Luego se indica el patrón:
void glLineStipple (GLint factor, GLushort patron)
0101010101010101
patron = 0x 5 5 5 5
factor = 3

9. Dibujo de triángulos
glBegin(GL_TRIANGLES);
glVertex2f (-50.0, 50.0);
glVertex3s (0, 100, 0);
glVertex3s (-100,100,-100);
...
glEnd();
• A partir de ahora, las líneas representan polígonos --> áreas
• La mayoría del hardware 3D está optimizado para triángulos
x
y
z
(0,100,0)
(-100,100,-100)
(-50,50,0)

10. Caras frontales y posteriores
glBegin(GL_TRIANGLES);
glVertex3s (); // vértice V0
glVertex3s (); // vértice V1
glVertex3s (); // vértice V2
glVertex3s (); // vértice V3
glVertex3s (); // vértice V4
glVertex3s (); // vértice V5
...
glEnd();
V0
V2
V1
V3
V4
V5
• El sentido anti-horario indica cuál es la cara frontal
• Cada cara puede tener propiedades diferentes
Sentido
antihorario
Sentido
horario
• Para que el sentido sea al revés:
void glFrontFace (GL_CW)

11. Modos de dibujo
• Por defecto, los polígonos se dibujan sólidos (sin aristas)
• Otras opciones son: hueco con aristas o sólo mostrando los vértices
• Cada cara puede mostrarse de forma diferente
void glPolygonMode (GLenum cara, GLenum modo)
GL_FRONT
GL_BACKGL_FRONT_AND_BACK
GL_POINT
GL_LINE
GL_FILL
glPolygonMode (GL_FRONT, GL_FILL) glPolygonMode (GL_BACK, GL_LINE)

12. Mallas de triángulos
• Para dibujar tiras de triángulos:
glBegin(GL_TRIANGLE_STRIP);
glVertex3s (); // vértice V0
glVertex3s (); // vértice V1
glVertex3s (); // vértice V2
glVertex3s (); // vértice V3
glVertex3s (); // vértice V4
...
glEnd();
V0
V2
V1
V0
V2
V1
V3
V0
V2
V1
V3
V4
• Ventajas:
– sólo se especifica un vértice por triángulo
– mejores efectos de iluminación al sombrear
la superficie total

13. Abanicos de triángulos
• Para dibujar abanicos de triángulos:
glBegin(GL_TRIANGLE_FAN);
glVertex3s (); // vértice V0
glVertex3s (); // vértice V1
glVertex3s (); // vértice V2
glVertex3s (); // vértice V3
glVertex3s (); // vértice V4
...
glEnd();
V0
V2
V1
V0
V2
V1
V3
• El vértice V0 es común a todos los
triángulos
V0
V2
V1
V3
V4

14. Cuadriláteros
glBegin(GL_QUADS);
glVertex2s (-50, 50); //V0
glVertex2s (100, 0); //V1
glVertex2s (100,100); //V2
glVertex2s (0,100); //V3
...
glEnd();
• Existe hardware de aceleración
para polígonos de más de 3
lados
x
y
z
(0,100,0)
(100, 100,0)
(-50,50,0)
(100, 0,0)
• Las caras frontales siguen siendo
en el sentido anti-horario
V0
V2
V1
V3

15. Mallas de cuadriláteros
• Para dibujar tiras de cuadriláteros:
glBegin(GL_QUAD_STRIP);
glVertex3s (); // vértice V0
glVertex3s (); // vértice V1
glVertex3s (); // vértice V2
glVertex3s (); // vértice V3
glVertex3s (); // vértice V4
glVertex3s (); // vértice V5
...
glEnd();
• Ventajas:
– sólo se especifican dos vértices
por polígono
– mejores efectos de iluminación
al sombrear la superficie total
V0
V2
V1
V3
V0
V3
V1
V2
V5
V4

16. Polígonos generales
glBegin(GL_POLYGON);
glVertex2s (-50, 50); //V0
glVertex2s (0, 0); //V1
glVertex2s (100,0); //V2
glVertex2s (100,100); //V3
glVertex2s (0,100); //V4
...
glEnd();
• Para cualquier número de lados
• Las caras frontales siguen siendo
en el sentido anti-horario
x
y
z
(0,100,0)
(100, 100,0)
(-50,50,0)
(100, 0,0)(0,0,0)
V0
V2V1
V3
V4

17. Relleno de polígonos
• Para rellenar con un patrón primero hay que activar el modo:
void glEnable (GL_POLYGON_STIPPLE)
• Luego se indica el patrón de relleno:
void glPolygonStipple (GLubyte bitmap[32x4])
= 0x0A 0x94

18. Reglas para los polígonos
• Debido a la optimización de los algoritmos internos de OpenGL, existen
tres restricciones para los polígonos:
– Todos los polígonos deben ser planares
– Las aristas no deben intersectarse
– Los polígonos deben ser convexos
Polígonos
válidos Polígonos
no válidos

19. Subdivisión y bordes
• Un polígono cóncavo puede
representarse como varios convexos
• Si se dibuja relleno, los bordes no se
apreciarán
• Si se dibuja en alambre, podemos
indicar qué aristas no queremos ver:
glEdgeFlag(TRUE);
// a partir de aquí, las aristas
son visibles
glVertex3s();
...
glEdgeFlag(FALSE); // a partir de
aquí, las aristas no se ven
glVertex3s();
...

20. Visualización de objetos 3D
• Las superficies de los objetos estarán formados por varias primitivas
• Para resolver el problema de visibilidad
glEnable (GL_DEPTH_TEST)
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
• Para desactivar una opción activada con glEnable se usa:
glDisable (GL_CULL_FACE)
• Para acelera el proceso, podemos indicar
que no se visualizen las caras traseras de
los polígonos
glEnable (GL_CULL_FACE)