Buen día, este algoritmo es el inicio de muchos que vamos a comenzar en este minicurso de opengl en las cuales les indicare las funciones mas importantes que se están usando en este algoritmo para hacer nuestra pequeña escena, espero les agrade y lo mas importante sea útil
Un poco de Teoría:
Sera importante comprender las funciones basicas que se requiere para manejar opengl
glutInit(&argc, argv);
Esta función es la que inicializa la GLUT y negocia con el sistema de
ventanas para abrir una. Los parámetros deben ser los mismos argc y argv, sin
modificar, de la función main(). Además, Glut entiende una serie
de parámetros que pueden ser pasados por línea de comandos.
glutInitDisplayMode(GLUT_SINGLE
| GLUT_RGB);
Define el modo en el que debe dibujar en la ventana. Los parámetros,
como gran parte de las funciones que iremos viendo, se definen con flags o
máscaras de bits. En este caso en concreto, GLUT_SINGLEindica que se debe
usar un solo buffer y GLUT_RGB el tipo de modelo de color con el que
se dibujará.
glutInitWindowPosition(50, 50);
Posición x e y de la esquina superior izquierda de la nueva ventana, con
respecto al escritorio en el que se trabaje.
glutInitWindowSize(500, 500);
El ancho y alto de la nueva ventana.
glutCreateWindow("Hello OpenGL");
Esta función es la que propiamente crea la ventana y el parámetro es el
nombre de la misma.
init();
En esta función, que hemos definido nosotros, activamos y definimos una
serie de estados de opengl, antes de pasar el control del programa a la GLUT.
glutDisplayFunc(display);
Aquí se define el primer callback. La función pasada como parámetro
será llamada cada vez que GLUT determine oportuno que la ventana debe ser redibujada,
como al maximizarse, poner otras ventanas por encima y después quitarlas, etc.
glutReshapeFunc(reshape);
Aquí definimos otro callback, en este caso para saber que hace
cuando la ventana es explícitamente reescalada. Esta acción afecta en principio
directamente al render, puesto que se está cambiando el tamaño del plano
de proyección. Por eso, en esta función (en este caso reshape), se suele
corregir esto de alguna forma. Lo veremos mejor más adelante.
glutMainLoop();
Esta función cede el control del flujo del programa a GLUT que, a partir
de estos "eventos", irá llamando a las funciones que han sido pasadas
como callbacks.
Contenido de los callbacks
Como se ha comentado, opengl puede ser vista como una maquina de estados. Por
lo tanto antes de empezar a hacer nada, habrá que configurar alguno de estos
estados. En init() podemos apreciar:
glClearColor(0,0,0,0);
Con esto se define el color con el que se borrara el buffer al hacer un glClear().
Los 3 primeros parámetros son las componentes R, G y B, siguiendo un rango de
[0..1]. La última es el valor alpha, del que hablaremos mas adelante.
Veamos ahora la función reshape(). Esta función, al ser pasada a glutReshapeFunc,
será llamada cada vez que se reescale a ventana. La función siempre debe ser
definida con el siguiente esqueleto:
void reshape(int, int) { ... }
El primer parámetro será el ancho y el segundo el alto, después del
reescalado (estos valores los manda el sistema de ventanas como parámetros del callback
glutReshapeFunc). Con estos dos valores trabajara la función cuando, en tiempo
de ejecución, el usuario reescale la ventana.
glViewport(0, 0, width, height);
Esta función define la porción de ventana donde puede dibujar ogl. Los
parámetros son, x e y (esquina inferior izquierda del "cuadro" donde
puede dibujar), ancho (width) y alto (height). Los valores de width y height se
toman, en este caso, de los parámetros de la función reshape(), pero se
pueden poner valores enteros. Los valores que se toman de width y heigh, los
manda el sistema de ventanas como parámetros del callback glutReshapeFunc para
el reescalado de la ventana, como ya se ha comentado.
glMatrixMode(GL_PROJECTION);
Especifica la matriz actual
para realizar la composición. En opengl las operaciones de rotación, translación,
escalado, etc. se realizan a través de matrices de transformación. Dependiendo
de lo que estemos tratando, hay tres tipos de matriz (que son los tres posibles flags que
puede llevar de parámetro la función): matriz de proyección (GL_PROJECTION),
matriz de modelo (GL_MODELVIEW) y matriz de textura (GL_TEXTURE). Con esta
función indicamos a cual de estas tres deben afectar las operaciones.
Concretamente, GL_PROJECTION afecta a las vistas o perspectivas o
proyecciones.
glLoadIdentity();
Con esto cargamos en la matriz actual la matriz identidad (equivale a resetear la
matriz).
glOrtho(-1, 1, -1, 1, -1, 1);
glOrtho() define una
perspectiva ortonormal. Esto quiere decir que lo que se ves será una proyección
paralela en uno de los planos definidos por los ejes. Los parámetros sirven
para delimitar el volumen de vista y son, por este orden: x_mínima, x_máxima, y_mínima, y_máxima, z_mínima, z_máxima,
(estos dos últimos no son coordenadas como los cuatro primeros, son distancias
desde el punto de vista, positivas hacia donde apunta y negativas hacia el lado
contrario) considerando que, por defecto, el punto de vista está en el origen
de coordenadas mirando hacia el eje negativo de z, estos valores son
desplazamientos desde este punto. Con estos seis valores se define el volumen
que incluirá los objetos que se proyecten
glMatrixMode(GL_MODELVIEW);
Se vuelve a este tipo de matrices, que afecta a las primitivas
geométricas.
Ya solo nos queda la función display() por ver. Como se ha dicho,
al ser pasada a glutDisplayFunc(), será llamada cada vez que haya que redibujar la
ventana. La función debe ser definida con el siguiente esqueleto:
void display(void) { ... }
Analicemos ahora el contenido de la función en nuestro ejemplo:
glClear(GL_COLOR_BUFFER_BIT);
Borra un buffer o una combinación de varios. En este caso, borra el
buffer de color (en realidad, cada componente R G y B tienen un buffer
distinto, pero aquí los trata como el mismo), el que se pinta después en
pantalla. Para borrarlos utiliza el color que ha sido previamente definido en init()
mediante glClearColor(), en este caso, el (0,0,0,0) es decir, pinta todo
el buffer de negro. La composición de colores se verá en el capítulo 5.
glColor3f(1,1,1);
Selecciona el color actual con el que dibujar. Parámetros R G y B, rango
[0..1], así que estamos ante el color blanco.
Explicación del Algoritmo:
Luego de haber inicializado nuestro escenario, procederemos
a “dibujar” las figuras que van a ir
dentro de el, desarrollaremos una función void
fondodeescritorio(); en la cual pondremos todo lo que iremos dibujando, en
mi caso me proyecto que el escenario debería tener un piso, cerros , un camino,
unas plantitas, una casita, un árbol, el sol y las nubes todo eso los iremos
dibujando por separado, optamos también por simplificar el trabajo y creamos
los procedimientos cuadrados y triángulos para usarlos cuando se requiera de
dichas figuras para formar otras mas complejas
Implementacion en C++:
Espero les haya agradado el escenario y recuerden que se pueden hacer cosas complejas a partir solo de algunas lineas,todo depende de su imaginación . Saludos.
SOCIALIZA ESTO →