Tabla de Contenido

Presentación...............................................................................................................................................1
Tabla de Contenido...................................................................................................................................2
Introducción...............................................................................................................................................3
Contenido...................................................................................................................................................4
 Código con sus debidos comentarios...............................................................................................4
 Imagen de la ejecución de su programa...........................................................................................9
Conclusión................................................................................................................................................10
Introducción

En el siguiente laboratorio haremos uso de las coordenadas primitivas para poder realizar un dibujo de
una cuidad pequeña. En este caso, se presentan 3 funciones, de las cuales son especificas para dibujar
cada uno de los elementos presentes en el resultado final. De esta forma y con el paso de las semanas los
laboratorios presentan un nivel de complejidad mayor y en este se notó en cierto modo.

2
Contenido

Código con sus debidos comentarios

#include <windows.h>
#include <GL/glut.h> //Inclusión típica de las librerías en el encabezado
inicial.
using namespace std;

void iniciarProyeccion()
{
glClearColor(0.0,0.9,1.0,0.0); //Selecciona el color de limpieza del fondo
glMatrixMode(GL_PROJECTION); //Inicialización de los valores de
visualización, reestablece el sistema de coordenadas
gluOrtho2D(-1,1,-1,1); //Definición 2d de la proyección de la matriz, es
decir, en que espacio se proyecta el dibujo en la pantalla.
}

void dibujarCalle(){
glBegin(GL_TRIANGLE_STRIP); // Se declara que cada par de vértices será interpretado
como un triángulo.
glColor3f(0.75f, 0.75f, 0.75f); //Declaramos que el color de los triángulos será gris claro.
glVertex2f(-1.0f, -0.4f);
glVertex2f(-1.0f, -1.0f);
glVertex2f(1.0f, -0.4f); //Denota la ubicación de los vértices que utilizaremos para
dibujar.
glVertex2f(1.0f, -1.0f);
glEnd(); //Delimita el final de especificación de vértices de primitivas
OpenGl
glBegin(GL_TRIANGLE_STRIP); // Se declara que cada par de vértices será interpretado
como un triángulo.
glColor3f(1, 1, 1); //Declaramos que el color de los triángulos será blanco.
glVertex2f(-1.0f, -0.71f);
glVertex2f(-1.0f, -0.66f);
glVertex2f(1.0f, -0.71f); //Denota la ubicación de los vértices que utilizaremos para
dibujar.
glVertex2f(1.0f, -0.66f);
glEnd();//Delimita el final de especificación de vértices de primitivas

3
OpenGl
}

void dibujarMontanas(){
glBegin(GL_TRIANGLE_STRIP); // Se declara que cada par de vértices será interpretado
como un triángulo.
glColor3f(0, 0.5f, 0); //Declaramos que el color de los triángulos será verde oscuro.
glVertex2f(-1.3f, -0.4);
glVertex2f(0.3f, -0.4f); //Denota la ubicación de los vértices que utilizaremos para
dibujar.
glVertex2f(-0.5f, 0.8f);
glEnd(); //Delimita el final de especificación de vértices de primitivas
OpenGl

glBegin(GL_TRIANGLE_STRIP); // Se declara que cada par de vértices será interpretado

como un triángulo.
glColor3f(0, 0.5f, 0); //Declaramos que el color de los triángulos será verde oscuro.
glVertex2f(-0.3f, -0.4f); //Denota la ubicación de los vértices que utilizaremos para
dibujar.
glVertex2f(1.3f, -0.4f);
glVertex2f(0.5f, 0.8f);
glEnd(); //Delimita el final de especificación de vértices de primitivas
OpenGl

void dibujarArbol(){
glBegin(GL_TRIANGLE_STRIP); // Se declara que cada par de vértices será interpretado
como un triángulo.
glColor3f(0.60f, 0.40f, 0.12f); //Declaramos que el color de los triángulos será chocolate.
glVertex2f(-0.07f, -1.0f);
glVertex2f(-0.07f, -0.7f);
glVertex2f(0.07f, -1.0f); //Denota la ubicación de los vértices que utilizaremos para
dibujar.
glVertex2f(0.07f, -0.7f);
glEnd(); //Delimita el final de especificación de vértices de primitivas
OpenGl

glBegin(GL_TRIANGLE_STRIP);
glColor3f(0, 0.4f, 0); //Declaramos que el color de los triángulos será verde oscuro.
glVertex2f(-0.2f, -0.71f);
glVertex2f(0.2f, -0.71f); //Denota la ubicación de los vértices que utilizaremos para
dibujar.
glVertex2f(0, -0.3f);
glEnd(); //Delimita el final de especificación de vértices de primitivas
OpenGl

4
 glBegin(GL_TRIANGLE_STRIP);
glColor3f(0, 1, 0); //Declaramos que el color de los triángulos será verde limón.
glVertex2f(-0.18f, -0.5f); //Denota la ubicación de los vértices que utilizaremos para
dibujar.
glVertex2f(0.18f, -0.5f);
glVertex2f(0, 0.15f);
glEnd(); //Delimita el final de especificación de vértices de primitivas
OpenGl

void dibujarVentanas(double w1, double w2, double z1, double z2)

{
for(GLdouble j=0;j<=0.25;j+=0.25){ Ciclo que convierte los valores decimales en double,
tomando un grupo de vertices para proyectar el dibujo. Se controla la columna en la que se
esta dibujando.
for(GLdouble k=0;k>=-0.50;k-=0.25){ Ciclo que convierte los valores decimales en
double, tomando un grupo de vertices para proyectar el dibujo. Se dibujan las 3 ventanas
en la columna que diga el ciclo anterior.
glBegin(GL_TRIANGLE_STRIP); // Se declara que cada par de vértices será
interpretado como un triángulo.
glColor3f(1.0f, 1.0f, 0.0f); //Declaramos que el color de los triángulos será amarillo.
glVertex2f(w1+j, z1+k);
glVertex2f(w1+j, z2+k); //Denota la ubicación de los vértices que utilizaremos para
dibujar.
glVertex2f(w2+j, z1+k);
glVertex2f(w2+j, z2+k);
glEnd(); //Delimita el final de especificación de vértices de primitivas OpenGl.

}
}
}

void dibujarEdificio(double x1, double x2, double y1, double y2, double r, double g, double b)
{
glBegin(GL_TRIANGLE_STRIP); // Se declara que cada par de vértices será interpretado
como un triángulo.
glColor3f(r, g, b); //Declaramos las variables para la asignación de color.
glVertex2f(x1, y1);
glVertex2f(x1, y2); //Denota la ubicación de los vértices que utilizaremos para dibujar.
glVertex2f(x2, y1);
glVertex2f(x2, y2);
glEnd(); //Delimita el final de especificación de vértices de primitivas OpenGl.
dibujarVentanas(x1-0.35, x2+0.09, 0.1, -0.07);
}

5
void dibujarSol(){
glPushMatrix(); // Establecer la matriz actual en la pila.
glTranslated(0,0.7,0); //Transformation 1.
glColor3f(1,1,0); //Declaramos que el color a utilizar será amarillo.
glutSolidSphere(0.15,20,20); //Declaramos el radio,longitud y latitud de la esfera.
glPopMatrix(); // saca la matriz superior de la pila.
}

void dibujarNubes (double x1, double y1) {

for(GLdouble i=0; i<=0.18;i+=0.09){ //Ciclo convierte los valores decimales recibidos en
dobles, tomando un grupo de vértices y permitiendo proyectar el dibujo en este caso las
nubes.
glPushMatrix(); // Establecer la matriz actual en la pila.
glTranslated(x1+i,y1,0); //Multiplica la matriz actual por una matriz de traducción.
glColor3f(1,1,1); //Declaramos que el color a utilizar será blanco.
glutSolidSphere(0.08,20,20); //Declaramos el radio,longitud y latitud de la esfera.
glPopMatrix(); //Saca la matriz superior de la pila.
}
}

void dibujar (void)

{
glClear(GL_COLOR_BUFFER_BIT); //Limpia la pantalla, borra todos los pixels.

dibujarMontanas();
dibujarCalle();
dibujarArbol();
dibujarEdificio(-0.3, -0.9, 0.2, -1, 1,0,0); //Envia los parámetros de color y coordenadas al
método.
dibujarEdificio(0.9, 0.3, 0.2, -1,1,0.5,0); //Envia los parámetros de color y coordenadas al
método.
dibujarSol();
dibujarNubes(-0.19,0.55); //Envia los parámetros de color al método.

dibujarNubes(0.04,0.55); //Envia los parámetros de color al método.

glFlush(); //Forza la ejecución de los comandos GL finitamente.

int main (int argc, char* argv [])

{
glutInit(&argc,argv); //Inicializa el ToolKit

6
 glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); //Selecciona el modo de
pantalla.
glutInitWindowSize(700,700); //Selecciona el tamaño de la ventana.
glutInitWindowPosition((glutGet(GLUT_SCREEN_WIDTH) - 700)/2,
(glutGet(GLUT_SCREEN_HEIGHT) - 700)/2); //Posiciona la ventana en la pantalla.
glutCreateWindow ("Paisaje en OpenGL"); //Abre la ventana y muestra en la parte
superior el nombre establecido.
iniciarProyeccion(); //Llamada el método.
glutDisplayFunc(dibujar); //Establece la devolución de llamada del método
dibujar para la ventana actual.
glutMainLoop(); // Bucle a la espera de eventos.

7
Imagen de la ejecución de su programa

8
Conclusión

Con la resolución de este laboratorio aprendimos a utilizar la coordenadas primitivas para dibujar
figuras especificas. Con respecto al código, se consiguió establecer diferentes funciones para
dibujar los elementos del dibujo y consideramos que se alcanzo los objetivos de esta semana.