Parcial 2

Curso:
- Computación Gráfica

Profesor:
- Víctor Enrique Quevedo Dioses

Alumnos:
- Edgar Flores Osís
- Katherine Berrú Ruiz

Tema: Animación

Programa utilizado:
- Codeblocks
 La Animación
Batman en Rotación y Movimiento 2D
La animación es muy importante dentro de los gráficos en computación la capacidad de conseguir
movimiento a partir de una secuencia de fotogramas o “frames”. La animación es fundamental
para un simulador de vuelo, una aplicación de mecánica industrial o un juego. En el momento en
que el ojo humano percibe más de 24 frames en un segundo, el cerebro lo interpreta como
movimiento real. En este momento, cualquier proyector convencional es capaz de alcanzar
frecuencias de 60 frames/s o más. Evidentemente, 60 fps (frames por segundo) será más suave (y,
por tanto, más real) que 30 fps. La clave para que la animación funcione es que cada frame esté
completo (haya terminado de renderizar) cuando sea mostrado por pantalla. Supongamos que
nuestro algoritmo (en pseudocódigo) para la animación es el siguiente ejemplo:

abre_ventana();

for (i=0; i< ultimo_frame; I++) {

borra_ventana();

dibuja_frame(i);

espera_hasta_la_1/24_parte_de_segundo();

Si el borrado de pantalla y el dibujado del frame tardan más de 1/24 de segundo, antes de que se
pueda dibujar el siguiente, el borrado ya se habrá producido. Esto causaría un parpadeo en la
pantalla puesto que no hay una sincronización en los tiempos. Para solucionar este problema, ogl
nos permite usar la clásica técnica del doble-buffering: las imágenes renderizadas se van
colocando en el primer buffer, y cuando termina el renderizado, se vuelca al segundo buffer, que
es el que se dibuja en pantalla. Así nunca veremos una imagen cortada, solventando el problema
del parpadeo. El algoritmo quedaría:
abre_ventana();

for (i=0; i< ultimo_frame; I++) {

borra_ventana();

dibuja_frame(i);

swap_buffers();

}
La cantidad de fps siempre quedará limitada por el refresco de nuestro monitor. Aunque OpenGL
sea capaz de renderizar 100 frames en un segundo, si el periférico utilizado (monitor, cañón) solo
nos alcanza los 60 hz., es decir, las 60 imágenes por segundo, aproximadamente 40 frames
renderizados se perderán.

Sentencias Principales:

INT : declara variable enteros

FLOAT :declara variable con decimales
RGB: red (“rojo”), green (“verde”) y blue (“azul”)
VOID: es una función sin tipo de retorno
GLCOLOR: sirve para asignar el color actual
GLBEGIN: delimitar los vértices de un primitivo o un grupo de similares primitivas

GL_QUADS: Dibuja un cuadrilátero por cada 4 vértices

GLVERTE: creación de los vértices.
GLEND: Finaliza el evento.
GLPUSHMATRIX : sirve para guardar la matriz actual el cual vas a dibujar , se guarda en memoria
GLPOPMATRIX: sirve para recuperar la matriz y lo muestra.
CASE: se utiliza para agilizar la toma de decisiones múltiples, trabaja de la misma manera que lo
harían sucesivos como if o if .. Else.
GL_TRIANGLE_STRIP: dibuja un triangulo
GL_LINE_LOOP: Se dibuja un segmento desde el vértice 0 al 1, del 1 al 2, del 2 al 3 y así
sucesivamente hasta trazar un segmento entre el último y penúltimo vértice, pero además dibuja
un segmento que une el último con el primer vértice
GLCLEARCOLOR: Este comando indica a OpenGL que cada vez que limpiemos el buffer de color.
Los parámetros corresponden a rojo, verde, azul y alfa respectivamente.
GLROTATEF: multiplicar la matriz actual por una matriz de rotación

GLVIEWPORT: Marca la región sobre la que queremos dibujar. Este comando por lo general es
llamado utilizando las dimensiones de la ventana como parámetros pero también puede
cambiarse si queremos dibujar diferentes escenas en un mismo objeto, un ejemplo puede ser
dibujar un espejo retrovisor.
GLMATRIXMODE: Cambia la matriz con la que se están haciendo operaciones.
GLLOADIDENTITY: Carga la matriz identidad a la matriz actual.
GLORTHO: Crea una proyección ortográfica.
GLSCALEF: sirve para el tamaño, de grande a pequeño
GLFLUSH: sirve para mostrar la imagen obtenida y borrarla, listo para volver a dibujar
nuevamente, forza la ejecución de comandos GL en tiempo finito

GLUTINITDISPLAYMODE: 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.
GLUT_SINGLE: significa que se va a trabajar con un solo búffer
GLUT_RGB: el tipo de modelo de color con el que se dibujará.
GLUORTHO2D: Sirve para crear el plano cartesiano
GLUTMAINLOOP: sirve para llamar a más funciones y controlan otras funciones que repiten
cuando sean necesarios, es un bucler inteligente.
main: es donde
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
main(). Glut entiende una serie de parámetros que pueden ser pasados por línea de comandos.
 Bote en Movimiento 2D
*Se hace un llamado a las librerías a utilizar.

#include <windows.h>

#ifdef __APPLE__

#include <GLUT/glut.h>

#else

#include <GL/glut.h>

#endif

#include <stdlib.h>

///Llamado de las librerías a utilizar

*Se Procede a realizar la función del “díbujo” que se va mover

void Bote() ///Función "Bote"

static float dist = 1.0; ///Declaración de la variable "dist" en su estado inicial

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);///Vuelve a los valores

predeterminados

///"GL_COLOR_BUFFER_BIT" Habilita los búfers para el renderizado

///"GL_DEPTH_BUFFER_BIT" indicar el búfer de profundidad

glPushMatrix(); /// guardar la matriz actual en una pila ("stack")

glTranslatef(dist, 0.0, 0.0); /// Multiplica la matriz actual por una Matriz de desplazamiento

//vela

glBegin(GL_TRIANGLES); ///Dibuja un triángulo

glVertex2f(0.0,0.2); ///Primer Vértice "2f": 2 números (porque está en 2D) y es de tipo float

glVertex2f(0.4,0.45); ///Segundo Vértice "2f": 2 números (porque está en 2D) y es de tipo float

glVertex2f(0.0,0.7); ///Tercer Vértice "2f": 2 números (porque está en 2D) y es de tipo float

glEnd(); ///Finalizar el evento

//Asta

glBegin(GL_QUADS); ///Dibuja un Rectángulo

glVertex2f(0.0,0.7); ///Primer Vértice "2f": 2 números (porque está en 2D) y es de tipo float

glVertex2f(-0.02,0.7); ///segundo Vértice "2f": 2 números (porque está en 2D) y es de tipo float

glVertex2f(-0.02,-0.1); ///Tercer Vértice "2f": 2 números (porque está en 2D) y es de tipo float
 glVertex2f(0.0,-0.1); ///Cuarto Vértice "2f": 2 números (porque está en 2D) y es de tipo float

glEnd(); ///Finalizar el evento

//Base

glBegin(GL_QUADS); ///Dibuja un Trapecio

glVertex2f(0.6,-0.1); ///Primer Vértice "2f": 2 números (porque está en 2D) y es de tipo float

glVertex2f(-0.6,-0.1); ///Segundo Vértice "2f": 2 números (porque está en 2D) y es de tipo float

glVertex2f(-0.4,-0.4); ///Tercer Vértice "2f": 2 números (porque está en 2D) y es de tipo float

glVertex2f(0.4,-0.4); ///Cuarto Vértice "2f": 2 números (porque está en 2D) y es de tipo float

glEnd(); ///Finalizar el evento

glPopMatrix(); /// recuperar la matriz guardada

dist -= 0.0009; ///La variable "dist" decrece a un ritmo de "0.0009"

if (dist < -1.5) dist = +1.5; ///Permite volver al estado inicial

glutSwapBuffers(); /// intercambiar las áreas donde se dibuja

glFlush(); ///Muestra y vacía el Búfer

int main(int argc, char** argv)

glutInit(&argc,argv); ///Inicializamos Glut

glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB); ///Inicializamos el modo de Video con algunos

parámetros

/// DOUBLE: "double búffer" sirve para dar mayor fuidez al tener 2 cuadros de dibujo.

/// RGB: utilizara los colore Red,Green y Blue

glutInitWindowSize(800,800); ///Inicializar el tamaño de la ventana

glutInitWindowPosition(0,0); ///Ubicar la posición de la ventana

glutCreateWindow("Bote"); ///Se crea la ventana con nombre las anteriores características

llamado "Bote"

glutDisplayFunc(Bote); /// Se llama a la función "Bote"

glutIdleFunc(Bote); /// la función que se llama cuando no está pasando nada

glutMainLoop(); /// Permite que las funciones GLUT que controlen otras funciones se repitan
cuando sea necesario "bucle inteligente"

}
 Ejemplo de Batman:
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>// libreria para uzar los signos matematicos
#include <GL/glut.h>
#define Frac_Circ 100 // Cien fracciones de circulo
#define PI 3.1415926535897932 // libreria para uzar pi
#include <math.h>
#define PI 3.1415936
void creaLetras(void){
glBegin(GL_POLYGON);
glColor3f(0,0,0);
}
void creaLogo(void){
glPushMatrix();
glRotatef(-34,0,0,1);
creaCuadrado();
glPopMatrix();
glPushMatrix();
glRotatef(214,0,0,1);
creaCuadrado();
glPopMatrix();
case 34:
bandera = 1;
break;
case 35:
bandera=0;
break;
case 50:
figura =50;
break;
case 51:
figura=51;
break;
case 52:
figura=52;
void creaCirculos(void){
glBegin(GL_POLYGON);
for (float i = 0;i<2*PI; i+=.0001){
dx = radio*cos(i)+cx;
dy = radio*sin(i)+cy;
glVertex2f(dx,dy);
}
glEnd();

}
void reiniciaEscala(void){
glScalef(0,0,0);
glEnd();
glFlush();
glPopMatrix();
glPushMatrix();
glRotatef(216,0,0,1);
creaPico();

glPopMatrix();
glPushMatrix();
glRotatef(288,0,0,1);
creaPico();

glPopMatrix();
glPopMatrix();
}
//float r,g,b;
//lilnea de arriba de la cabeza
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2f(-5,11);
glVertex2f(-5,12);
glVertex2f(4,12);
glVertex2f(4,11);

glEnd();

glColor3f(0,0,1);
glColor3f(1,1,1);
glBegin(GL_QUADS);
glVertex2f(-5,7);
glVertex2f(-5,6);
glVertex2f(-4,6);
glVertex2f(-4,7);
glEnd();

glColor3f(1,1,1);
glBegin(GL_QUADS);
glVertex2f(1,4);
glVertex2f(1,6);
glVertex2f(4,6);
glVertex2f(4,4);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2f(-5,-5);
glVertex2f(-5,-8);
glVertex2f(-3,-8);
glVertex2f(-3,-5);
glBegin(GL_QUADS);
glVertex2f(-4,-4);
glVertex2f(-4,-5);
glVertex2f(-3,-5);
glVertex2f(-3,-4);
glBegin(GL_QUADS);
glVertex2f(-4,-8);
glVertex2f(-4,-9);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2f(-11,-8);
glVertex2f(-11,-12);
glVertex2f(-6,-12);
glVertex2f(-6,-8);
glEnd();

glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2f(5,-8);
glVertex2f(5,-12);
glVertex2f(10,-12);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2f(-3,-11);
glVertex2f(-3,-12);
glVertex2f(-2,-12);
glVertex2f(-2,-11);
glEnd();

glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2f(1,-11);
glVertex2f(1,-12);
glVertex2f(2,-12);
//aqui empiezan los bloques
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2f(-13,-5);
glVertex2f(-13,-6);
glVertex2f(-9,-6);
glVertex2f(-9,-5);
glEnd();

glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2f(-12,-4);
glVertex2f(-12,-5);
glVertex2f(-8,-5);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2f(5,-2);
glVertex2f(5,-3);
glVertex2f(9,-3);
glVertex2f(9,-2);
glEnd();

glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2f(6,-3);
glVertex2f(6,-4);
glVertex2f(10,-4);
glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2f(-7,1);
glVertex2f(-7,-1);
glVertex2f(-6,-1);
glVertex2f(-6,1);
glEnd();

glColor3f(0,0,0);
glBegin(GL_QUADS);
glVertex2f(-6,-1);
glVertex2f(-6,-2);
glVertex2f(5,-2);
glColor3f(0,0,1);
glBegin(GL_QUADS);
glVertex2f(-10,-3);
glVertex2f(-10,-4);
glVertex2f(-8,-4);
glVertex2f(-8,-3);
glEnd();

glColor3f(0,0,1);
glBegin(GL_QUADS);
glVertex2f(7,-3);
glVertex2f(7,-4);
glVertex2f(9,-4);
glVertex2f(9,-3);
glColor3f(0,0,1);
glBegin(GL_QUADS);
glVertex2f(-12,-6);
glVertex2f(-12,-12);
glVertex2f(-11,-12);
glVertex2f(-11,-6);
glEnd();

glColor3f(0,0,1);
glBegin(GL_QUADS);
glVertex2f(10,-6);
glVertex2f(10,-12);
void animar(void) {
rotar=rotar+inc;
if (botar==1){
ang=ang+0.001;
ry=10*cos(ang);
}
if (botar==2){
ang=ang+0.001;
rx=10*sin(ang);
}
glutPostRedisplay();
}
glutAddSubMenu("Color", colores);
glutAddSubMenu("GrayScale",gs);
glutAddSubMenu("State", state);
glutAddSubMenu("Figura",figura);
glutAddSubMenu("Eje",eje);
glutAttachMenu(GLUT_RIGHT_BUTTON);

void ajustar(int ancho, int alto)

{

float aspectratio;