Practicas Semestre

Ingeniera en Sistemas Computacionales
Tema:
Prcticas en Dev c++
Alumno:
Ortega Juan de Dios Alberto
Grupo:
6s1
Materia:
Graficacin
Profesora:
Daniel Zarco Mrquez
Objetivo.
Dar a conocer todas las prcticas realizadas durante el semestre,
mediante el uso de Open Gl y Dev C++ as como cada funcin o mtodo
que fue utilizado de diferentes formas.
Practicas.
1)desplazamiento diagonal de un cuadrado
2)Nombre formado con lneas
3)rotacin de un circulo alrededor de otro
4)crculos mltiples con movimiento
5)Figura con movimiento 2D de teclas
6)Numero 8 con rotacin
7)Ondas con movimiento
8)Onda sin movimiento
9)Tetera con funcin de teclas
10)Tetera con iluminacin
11)Rotacin y translacin
12)Semforo
13)Varias figuras con funciones
14)Sombra de una figura
15)Lnea
16)Multilineas
17)Cubo 3D
18)Figura plana 2D
1)#include <math.h>
#include <GL/glut.h>
float x= 0;
float x1=0;
void dibujar (int w, int h)
{
glClearColor(1,0,0,0);
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-10,10,-10,10);
}
void pantalla (void)
{
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS);
{
glVertex2f(-9+x,-9+x1);
glEnd();
glFlush();
}
}
void avanzar (int value)
{ if(x<=15);
{x= x+1;
if (x>15)
{
x=15;
}
}
glutTimerFunc(100,avanzar,1);
glutPostRedisplay();
}
int main (int argc,char** argv)
{
glutInit(&argc,argv);
glutInitWindowSize(500,500);
glutInitWindowPosition(300,10);
glutCreateWindow("movimiento");
//glClearColor(0.0,0.0,0.0,0)
glutDisplayFunc(pantalla);
glutReshapeFunc(dibujar);
glutMainLoop();
return 0;
}
2) #include <gl/glut.h>
#include<math.h>
float x= 0;
float x1=0;
float p9x=-13+x, p9y=-20+x1, radio9=4,cal9x, cal9y;
void dibujar (int w, int h){
glLoadIdentity();
gluOrtho2D(-30,30,-30,30);
glBegin(GL_QUADS);
glColor3f(0.455,0.677,0.233);
glVertex2f(-30,30);
glVertex2f(30,30);
glVertex2f(30,0);
glVertex2f(-30,0);
glEnd();
void pantalla(void){
glBegin(GL_TRIANGLE_FAN); ///
glColor3f(4.0,4.0,4.0);
for (double i=0.0; i<10; i+=0.001)
{ cal9x=radio9*cos(i)+p9x;
cal9y=radio9*sin(i)+p9y;
glVertex2f(cal9x+x,cal9y+x1);
}
glEnd();
glFlush(); ///bola
{
glBegin(GL_LINES); //nombre
glVertex2i(-21,3); ////A
glVertex2i(-19,8);
glVertex2i(-17,3);
glVertex2i(-19,8);
glVertex2i(-20,4);
glVertex2i(-18,4);
glVertex2i(-16,3); //L
glVertex2i(-16,8);
glVertex2i(-16,3);
glVertex2i(-14,3);
glVertex2i(-13,8); //B
glVertex2i(-13,3);
glVertex2i(-13,8);
glVertex2i(-11,8);
glVertex2i(-13,3);
glVertex2i(-11,3);
glVertex2i(-13,5.5);
glVertex2i(-11,3);
glVertex2i(-11,8);
glVertex2i(-11,3);
glVertex2i(-10,3);//E
glVertex2i(-10,8);
glVertex2i(-10,5);
glVertex2i(-9,5);
glVertex2i(-10,8);
glVertex2i(-8,8);
glVertex2i(-10,3);
glVertex2i(-8,3);
glVertex2i(-7,3);//R
glVertex2i(-7,8);
glVertex2i(-7,8);
glVertex2i(-5,8);
glVertex2i(-7,5);
glVertex2i(-5,5);
glVertex2i(-7,5);
glVertex2i(-5,3);
glVertex2i(-5,8);
glVertex2i(-5,5);
glVertex2i(-4,8);//T
glVertex2i(0,8);
glVertex2i(-2,8);
glVertex2i(-2,3);
glVertex2i(1,8);//O
glVertex2i(1,3);
glVertex2i(3,8);
glVertex2i(3,3);
glVertex2i(1,8);
glVertex2i(3,8);
glVertex2i(1,3);
glVertex2i(3,3);
glVertex2i(6,8);//O
glVertex2i(6,3);
glVertex2i(8,8);
glVertex2i(8,3);
glVertex2i(6,8);
glVertex2i(8,8);
glVertex2i(6,3);
glVertex2i(8,3);
glVertex2i(12,3);//R
glVertex2i(12,8);
glVertex2i(12,8);
glVertex2i(10,8);
glVertex2i(12,5);
glVertex2i(10,5);
glVertex2i(12,5);
glVertex2i(10,3);
glVertex2i(10,8);
glVertex2i(10,5);
glVertex2i(13,8);//T
glVertex2i(17,8);
glVertex2i(15,8);
glVertex2i(15,3);
glVertex2i(18,3);//E
glVertex2i(18,8);
glVertex2i(18,5);
glVertex2i(20,5);
glVertex2i(18,8);
glVertex2i(20,8);
glVertex2i(18,3);
glVertex2i(20,3);
glVertex2i(21,3); //G
glVertex2i(21,8);
glVertex2i(21,3);
glVertex2i(23,3);
glVertex2i(21,8);
glVertex2i(23,8);
glVertex2i(23,5);
glVertex2i(23,3);
glVertex2i(21,5);
glVertex2i(23,5);
glVertex2i(24,3); ////A
glVertex2i(26,8);
glVertex2i(28,3);
glVertex2i(26,8);
glVertex2i(24,5);
glVertex2i(28,5);
glEnd();
glFlush();
}
if(x<=30);
{
x= x+1;
if (x>30)
{
x=30;
}
}
}
int main(int argc,char**argv)
{
glutCreateWindow("examen");
glutMainLoop();
return 0;
}
#include<math.h>
float x= 0; //variable declarada

float x1= 1;
float px=0, py=7.7, radio =4, calx, caly;

float p2x=11+x, p2y=1.5+x1, radio2 =1, cal2x, cal2y;
void dibujar (int w, int h){ //metodo dibujar con 2 parametros enteros w&h
glLoadIdentity();
gluOrtho2D(-25,25,-25,25); //definir volumen de trabajo plano en x y y
}
void pantalla(void){ //metodo
glClearColor(0.1,0.0,0.0,0.0);
glClear(GL_COLOR_BUFFER_BIT);//limpiar la pantalla
glBegin(GL_TRIANGLE_FAN);
glColor3f(1.0, 1.0, 1.0);
for (double i=0.0; i<10; i+=0.001)

{ calx=radio*cos(i)+px;
caly=radio*sin(i)+py;
glVertex2f(calx,caly);
}
glEnd();
glFlush();
glColor3f(1.0, 1.0, 1.0);

for (double i=0.0; i<10; i+=0.001)
{ cal2x=radio2*cos(i)+p2x;
cal2y=radio2*sin(i)+p2y;
glVertex2f(cal2x+x,cal2y+x1);
}
glEnd();
glFlush();

{
if(x<=0.0001)
{
x = x++;
if(x>0.0001)
{
x=0.0001;
}
}
}
{
glutCreateWindow("tarea");
glutMainLoop();
return 0;
}
4) #include <Gl/glut.h>
#include <Gl/gl.h>
#include <math.h>
int x=1, x2=1, y=1;

double a=6.15, b=7.15,c=8.15, d=9.15,e=10.15,f=11.15; //declaracion de variables
void inicializa(void)
{
glClearColor(.3450,.0,.0,.770);
glLoadIdentity();
gluOrtho2D(80.0, 500.0, 80.0, 500.0); //ancho y largo de la ventana
}
void circulo(int x, int y, int radio) {
int angulo=0;
glVertex2f(x,y);
for (angulo=0;angulo<=360; angulo+=6) { glVertex2f(x + sin(angulo) * radio, y
+ cos(angulo) * radio);}
glEnd();
}
void dibuja(void) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(7.890,0.543,0.123);
circulo(300,300,70);
glColor3f(.98,.86,.65);
circulo(300,300,50);
glColor3f(8.0,.78,.98);
if (a>=6.15 && a<=500) {
circulo(300 + sin(a) * 60,300 - cos(a) * 60,10);
a=a+0.1;
}
glColor3f(2.78,2.81,3.01);
if (b>=6.15 && b<=500) {
circulo(300 + sin(b) * 60,300 - cos(b) * 60,10);
b=b+0.1;
}
glColor3f(1.01,2.01,0.01);
if (c>=6.15 && c<=500) {
circulo(300 + sin(c) * 60,300 - cos(c) * 60,10);
c=c+0.1;
}
glColor3f(.01,2.01,0.01);
if (d>=6.15 && d<=500) {
circulo(300 + sin(d) * 60,300 - cos(d) * 60,10);
d=d+0.1;
}
glColor3f(.01,2.01,0.01);
if (e>=6.15 && e<=500 ) {
circulo(300 + sin(e) * 60,300 - cos(e) * 60,10);
e=e+0.1;
}
glColor3f(.01,2.01,0.01);
if (f>=6.15 && f<=500) {
circulo(300 + sin(f) * 60,300 - cos(f) * 60,10);
f=f+0.1;
}
for (int j=0; j<=100000000;j++){}
glFlush();
glutSwapBuffers(); //cambio de buffer
}
int main (int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH); //declaracion de doble
buffer
inicializa();
glutDisplayFunc(dibuja);
glutIdleFunc(dibuja);
glutMainLoop();
return 0;
}
5) #include <stdio.h>
#include <math.h>
void display();
void specialKeys();
double rotate_y=0;
double rotate_x=0;
void display(){
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glRotatef( rotate_x, 1.0, 0.0, 0.0 );

glRotatef( rotate_y, 0.0, 1.0, 0.0 );
glClearColor (0.0f, 0.0f, 0.0f, 0.0f);

glClear (GL_COLOR_BUFFER_BIT);
glPushMatrix ();
glBegin (GL_POLYGON);
glColor3f( 1.0, 0.0, 0.0 );
glVertex3f( 0.5, -0.5, -0.5 );
// P1 es rojo
glColor3f( 0.0, 1.0, 0.0 );
glVertex3f( 0.5, 0.5, -0.5 );
// P2 es verde
glColor3f( 0.0, 0.0, 1.0 );
glVertex3f( -0.5, 0.5, -0.5 );
// P3 es azul
glColor3f( 1.0, 0.0, 1.0 );
glVertex3f( -0.5, -0.5, -0.5 );
glEnd ();
glBegin (GL_POLYGON);
glColor3f (1.0, 1.0, 0.0); glVertex3f (0.0, 1.0, 0.0);
glColor3f (0.0, 1.0, 0.0); glVertex3f (0.80, -0.5, 0.0);
glColor3f (1.0, 0.0, 1.0); glVertex3f (-0.80, -0.5, 0.0);
glEnd ();
glPointSize(20);
glBegin(GL_POINTS);
glColor3f( 1.0, 0.0, 0.0 ); glVertex3f( 0.5, -0.5, 0.5 );
glColor3f( 0.0, 1.0, 1.0 ); glVertex3f( 0.5, 0.5, 0.5 );
glColor3f( 0.0, 0.0, 1.0 ); glVertex3f( -0.5, 0.5, 0.5 );
glColor3f( 1.0, 0.0, 1.0 ); glVertex3f( -0.5, -0.5, 0.5 );
glEnd();
glPopMatrix ();
glutSwapBuffers();
void specialKeys( int key, int x, int y ) {
if (key == GLUT_KEY_RIGHT)
rotate_y += 15;
else if (key == GLUT_KEY_LEFT)

rotate_y -= 15;
else if (key == GLUT_KEY_UP)

rotate_x += 15;
else if (key == GLUT_KEY_DOWN)

rotate_x -= 15;
int main(int argc, char* argv[]){

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutCreateWindow("Multicolor");
glEnable(GL_DEPTH_TEST);
glutDisplayFunc(display);
glutSpecialFunc(specialKeys);
glutMainLoop();
return 0;
6) #include <unistd.h>
#include <Gl/glut.h>
#include <Gl/gl.h>
#include <math.h>
int x=1, x2=1, y=1;
double a=6.15, b=6.15 ,c=-6.15, d=-6.15;
//declaracion de variables
{
glLoadIdentity();
}
void circulo(int x, int y, int radio) {
int angulo=0;
glVertex2f(x,y);
for (angulo=0;angulo<=360; angulo+=2) { glVertex2f(x + sin(angulo) * radio, y
+ cos(angulo) * radio);}
glEnd();
}
void dibuja(void) {
glColor3f(0.3,0.3,0.6);
circulo(300,300,70);
circulo(300,180,70);
glColor3f(1.1,1.1,1.1);
circulo(300,300,50);
circulo(300,180,50);
glColor3f(1.1,0.1,0.2);
circulo(300,300,30);
glColor3f(1.1,0.1,0.2);
circulo(300,300,30);
circulo(300,180,30);
glColor3f(0.0,3.0,0.0);
if (a>=6.15 && a<=12.4) {
circulo(300 + sin(a) * 60,300 - cos(a) * 60,10);
a=a+0.1;
}
else{
circulo(300 + sin(b) * 60,180 - cos(b) * -60,10);
b=b+0.1;
if(b>12.4) {a=6.15;b=6.15;}
}
glColor3f(1.0,3.0,0.0);
if (c>=6.15 && c<=12.4) {
circulo(300 + sin(c) * 60,300 - cos(c) * -60,10);
c=c-0.1;
}
else{
circulo(300 + sin(d) * 60,180 - cos(d) * -60,10);
d=d-0.1;
if(d>12.4) {c=6.15;d=6.15;}
}
for (int j=0; j<=10000000;j++) {}
glFlush();
glutSwapBuffers(); //cambio de buffer
}
buffer
inicializa();
glutMainLoop();
return 0;
}
7) #include <GL/glut.h>
#include <math.h>
float z= 0;
float x1=0;
void dibujar(int w,int h)

{
glLoadIdentity();
gluOrtho2D(-9,9,-9,9);
}
void pantalla(void)
{
float x,y;
glBegin(GL_LINE_STRIP);
for(x=-8;x<=8;x+=0.01){
y=4+sin(x+z);
glColor3f(1.0,1.0,1.0);
glVertex2f(x+z,y+x1);
y=-4+cos(x+x1);
}
glEnd();
for(x=-8;x<=8;x+=0.01){
y=2-sin(x+z);
glColor3f(1.0,1.0,1.0);
glVertex2f(x-z,y-x1);
y=-2-cos(x-x1);
}
glEnd();
for(x=-8;x<=8;x+=0.01){
y=0+sin(x+z);
glColor3f(1.0,1.0,1.0);
glVertex2f(x+z,y+x1);
y=-0+cos(x+x1);
}
glEnd();
for(x=-8;x<=8;x+=0.01){
y=-2-sin(x+z);
glColor3f(1.0,1.0,1.0);
glVertex2f(x-z,y-x1);
y=-2-cos(x-x1);
}
glEnd();
glFlush();
}
{
if(z<=15);
{
z=z+1;
if (z>15)
{
z=-15;
}
}
}
int main(int argc,char**rgb)
{
glutInit(&argc,rgb);
glutCreateWindow("ONDAS");
glutMainLoop();
return 0;
}
#include <math.h>
float z= 0;
float x1=0;
void dibujar(int w,int h)
{
glLoadIdentity();
gluOrtho2D(-10,10,-10,10);
}
void pantalla(void)
{
float x,y;
for(x=-10;x<=10;x+=0.01){
y=6+sin(x);
glColor3f(1.0,0.0,1.0);
glVertex2f(x+z,y);
y=-6+cos(x+x1);
}
glEnd();
glFlush();
}
{
if(z<=15);
{
z=z+1;
if (z>15)
{
z=-15;
}
}
}
int main(int argc,char**rgb)
{
glutInit(&argc,rgb);
glutCreateWindow("ONDAS");
glutMainLoop();
return 0;
}
float aspect = 1.0f;

void display();
void specialKeys();
double rotate_y=0;
double rotate_x=0;
double rotate_z=0;
double rotate_w=0;
void display(void) {
glLoadIdentity();
gluPerspective(20.0f, 1.0f, 1.0f, 10.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef( 1.0, 1.0, -10.0 );
glColor3f(0.6,0.9,0);
glutSolidTeapot(0.5);
glFlush();
glutSwapBuffers();
}
void specialKeys( int key, int x, int y ) {
// Flecha derecha: aumentar rotacin 5 grados

rotate_y += 10;
// Flecha izquierda: disminuir rotacin 5 grados

rotate_x -= 10;

rotate_z += 10;

rotate_w -= 10;
// Solicitar actualizacin de visualizacin

void onSize(int sx, int sy) {

glViewport(0, 0, sx, sy);
aspect = (float) sx / (float) sy;
}
int main(int argc,char**argv) {
glutInitWindowSize(400, 400);
glutInitWindowPosition(100, 100);
glutCreateWindow("Ejemplo");
glutReshapeFunc(onSize);
glutMainLoop();
}

#include <stdlib.h>
//angulo de rotacin
GLfloat angulo = 0.0;
//inicializo la fuente de luz y las demas variables

void init(void)
{
GLfloat light_ambient[] = { 0.75, 0.75, 0.75, 1.0 };
GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat light_position[] = { 0.1, 0.25, 1.0, 0.0 };
glLightfv (GL_LIGHT0, GL_AMBIENT, light_ambient);

glLightfv (GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv (GL_LIGHT0, GL_SPECULAR, light_specular);
glLightfv (GL_LIGHT0, GL_POSITION, light_position);
glEnable (GL_LIGHTING);
glEnable (GL_LIGHT0);
glShadeModel(GL_SMOOTH);
glClearDepth(1.0f);
glDepthFunc(GL_LEQUAL);
glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
}
void display(void)
{
//defino un material en este caso es un Rojo
GLfloat mat_ambient[] = {0.1, 0.1, 0.1, 1.0f};
GLfloat mat_diffuse[] = {0.308, 0.615, 0.824, 1.0f};
GLfloat mat_specular[] = {1.0, 1.0, 1.0, 1.0f};
glLoadIdentity();
glTranslatef(0.0f,0.0f,-10.0f);
//aplico la rotacion al eje Y
glRotatef(angulo, 0.0f, 1.0f, 0.0f);
//aplico el material
glMaterialfv (GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv (GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv (GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialf (GL_FRONT, GL_SHININESS, 50.0f);
//este objeto esta definido en GLUT

glutSolidTeapot(2.5);
//intercambio los Buffers

glutSwapBuffers();
}
//utilizo la perspectiva
void reshape (int width, int height)
{
if (height==0)
{
height=1;
}
glViewport(0,0,width,height);
glLoadIdentity();
gluPerspective(60.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);
glLoadIdentity();
}
// salgo si se preciona ESC

void keyboard(unsigned char key, int x, int y)
{
switch (key)
{
case 27: exit(0);
break;
}
}
//que hacer en ausencia de entrada

void Idle(void)
{
//incrementa el angulo de rotacin
angulo += 0.5;
//redibuja la ventana
display();
}
int main(int argc, char** argv)

{
//inicializa la ventana en el modo Doble Buffer

glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize (300, 300);
glutInitWindowPosition (0, 0);
glutCreateWindow ("Rotacion 3D");
init ();
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutIdleFunc(Idle);
//inicia el proceso de eventos

glutMainLoop();
return 0;
}
GLfloat anguloCuboX = 0.0f;

GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;
GLint ancho=400;
GLint alto=400;
int hazPerspectiva = 0;
void reshape(int width, int height)

{
glViewport(0, 0, width, height);
glLoadIdentity();
if(hazPerspectiva)
gluPerspective(60.0f, (GLfloat)width/(GLfloat)height, 1.0f, 20.0f);
else
glOrtho(-4,4, -4, 4, 1, 10);
ancho = width;
alto = height;
}
void drawCube(void)
{
glColor3f(1.0f, 0.0f, 0.0f);
glBegin(GL_QUADS);
//cara frontal
glVertex3f(-1.0f, -1.0f, 1.0f);

glVertex3f( 1.0f, -1.0f, 1.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);
glEnd();
glColor3f(0.0f, 1.0f, 0.0f);
glBegin(GL_QUADS);
//cara trasera
glVertex3f( 1.0f, -1.0f, -1.0f);

glVertex3f(-1.0f, -1.0f, -1.0f);
glVertex3f(-1.0f, 1.0f, -1.0f);
glVertex3f( 1.0f, 1.0f, -1.0f);
glEnd();
glColor3f(0.0f, 0.0f, 1.0f);

glBegin(GL_QUADS);
//cara lateral izq
glVertex3f(-1.0f,-1.0f, -1.0f);
glVertex3f(-1.0f,-1.0f, 1.0f);
glVertex3f(-1.0f, 1.0f, -1.0f);
glEnd();
glColor3f(1.0f, 1.0f, 0.0f);

glBegin(GL_QUADS);
//cara lateral dcha
glVertex3f(1.0f, -1.0f, 1.0f);

glVertex3f(1.0f, -1.0f, -1.0f);
glVertex3f(1.0f, 1.0f, -1.0f);
glVertex3f(1.0f, 1.0f, 1.0f);
glEnd();
glColor3f(0.0f,
1.0f, 1.0f);
glBegin(GL_QUADS);
//cara arriba

glVertex3f( 1.0f, 1.0f, 1.0f);
glVertex3f( 1.0f, 1.0f, -1.0f);
glVertex3f(-1.0f, 1.0f, -1.0f);
glEnd();
glColor3f(1.0f, 0.0f, 1.0f);

glBegin(GL_QUADS);
//cara abajo
glVertex3f( 1.0f,-1.0f, -1.0f);

glVertex3f( 1.0f,-1.0f, 1.0f);
glVertex3f(-1.0f,-1.0f, 1.0f);
glVertex3f(-1.0f,-1.0f, -1.0f);
glEnd();
}
void display()
{
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -5.0f);
glRotatef(anguloCuboX, 1.0f, 0.0f, 0.0f);

glRotatef(anguloCuboY, 0.0f, 1.0f, 0.0f);
drawCube();
glLoadIdentity();

glRotatef(anguloEsfera, 0.0f, 1.0f, 0.0f);
glTranslatef(3.0f, 0.0f, 0.0f);
glColor3f(1.0f, 1.0f, 1.0f);

glutWireSphere(0.5f, 8, 8);
glFlush();
glutSwapBuffers();
anguloCuboX+=0.1f;
anguloCuboY+=0.1f;
anguloEsfera+=0.2f;
}
void init()
{
glClearColor(0,0,0,0);
ancho = 400;
alto = 400;
}
void idle()
{
display();
}
void keyboard(unsigned char key, int x, int y)

{
switch(key)
{
case 'p':
case 'P':
hazPerspectiva=1;
reshape(ancho,alto);
break;
case 'o':
case 'O':
hazPerspectiva=0;
reshape(ancho,alto);
break;
case 27: // escape

exit(0);
break;
}
}
int main(int argc, char **argv)

{
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(100, 100);
glutInitWindowSize(ancho, alto);
glutCreateWindow("Cubo 1");
init();
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}
12) #include <unistd.h>

#include <Gl/glut.h>
#include <Gl/gl.h>
#include <math.h>
int xs=1, ys=1;
double as=6.15, bs=6.15;
//declaracion de variables
{
glLoadIdentity();
}
void circulo(int xs, int ys, int radios) {
int angulo=0;
glVertex2f(xs,ys);
for (angulo=0;angulo<=360; angulo+=6) { glVertex2f(xs + sin(angulo) * radios,
ys + cos(angulo) * radios);}
glEnd();
}
void dibuja(void)
{
glBegin(GL_QUADS);//Cuadros fondo semaforo
glColor3f(0.0 , 0.2 , 0.2);
glVertex2i(170,437);
glVertex2i(278,3);
glVertex2i(229,3);
glEnd();
glColor3f(0.0,0.0,0.0);//Luces Verde
circulo(247,226,34);
glColor3f(0.0,0.0,0.0);//Luces Amarrilla
circulo(247,302,34);
glColor3f(0.0,0.0,0.0);//Luces Roja
circulo(247,381,34);
as=as+1; //velocidad entre mas grande mas rapido y entre menos mas lento
for(int j=1;j<=10000000;j++){}//pausa
if(as>1 && as<20){
circulo(247,381,34);
}
if(as>20 && as<45){

circulo(247,226,34);
}// se repite idefinidamente
if(as>45 && as<55){
circulo(247,226,34);
if(as>55 && as<55){
circulo(247,302,34);
if(as>50 && as<60){

circulo(247,302,34);
if(as>50 && as<55){

circulo(247,302,34);
if(as>60){as=0;}
glFlush(); //forzar dibujado
glutSwapBuffers();
}

buffer
inicializa();
glutMainLoop();
return 0;
}
glLoadIdentity();

}
glPointSize(5);
glBegin(GL_POINTS);//trazo d linea
glColor3f(1,2,1);//color
glVertex2f(-4,4);//vertices de punto a punto

glVertex2f(-9,4);
glVertex2f(-6.5,4);
glVertex2f(-4,9);
glVertex2f(-9,9);
glVertex2f(-6.5,9);
glEnd();
glBegin(GL_QUADS);
glVertex2f(9,-9);
glVertex2f(9,-5);
glVertex2f(5,-5);
glVertex2f(5,-9);
glEnd();
glBegin(GL_LINES);
glVertex2f(-9,-4);
glVertex2f(-9,-9);
glVertex2f(-9,-4);
glVertex2f(-4,-4);
glVertex2f(-4,-9);
glVertex2f(-4,-4);
glVertex2f(-9,-9);
glVertex2f(-4,-9);
glVertex2f(-4,-4);
glVertex2f(-6.5,-9);
glVertex2f(-9,-4);
glEnd();
glVertex2f(9,3);
glVertex2f(3,3);
glVertex2f(6,8);
glEnd();
glBegin(GL_POLYGON);
glVertex2i(4,0);
glVertex2i(2.5,-3.5);
glVertex2i(-2.5,-3.5);
glVertex2i(-4,0);
glVertex2i(-2.5,3.5);
glVertex2i(2.5,3.5);
glEnd();
glFlush();//termina
}
int main(int argc,char**argv)//cuerpo manda a llamar metodo y dibujar
{
glutInit(&argc,argv); //
glutCreateWindow("MARCO ANTONIO");
glutMainLoop();
return 0;
}
glLoadIdentity();
}
void pantalla(void){
glClearColor(0.3,0.6,1,1); //metodo
glBegin(GL_QUADS); //fondo rosa

glColor3f(1,0,1);
glVertex2f(-15,15);
glVertex2f(15,15);
glVertex2f(15,15);
glVertex2f(15,-15);
glEnd();
glFlush();
glColor3f(1,1,1);
glBegin(GL_QUADS); ///rectangulo
glColor3f(1,1,1);
glVertex2f(8,0);
glVertex2f(-8,0);
glVertex2f(-8,-8);
glVertex2f(8,-12);
glEnd();
glFlush();
glBegin(GL_TRIANGLE_FAN); //sombra
glColor3f(0,0,0);
glVertex2f(9,-10);
glVertex2f(8,0);
glVertex2f(8,-12);
glEnd();
glFlush();
}
{
glutCreateWindow("sombra");
glutMainLoop();
return 0;
}
15) #include <windows.h>
#include <gl/gl.h>
#include <gl/glut.h> //librera
glLoadIdentity();
gluOrtho2D(5,-5,5,-5); //definir volumen de trabajo plano en x y y

}
glBegin(GL_LINES);//trazo d linea
glVertex2f(0,0);//F flotante i entero
glVertex2f(3,3);//vertices de punto a punto
glEnd();
glFlush();//termina
}
{
glutCreateWindow("PROFE ZARCO");//nombre ventana
glutMainLoop();
return 0;
16) #include <windows.h>

#include <gl/gl.h>
#include <gl/glut.h> //libreria
glLoadIdentity();
gluOrtho2D(10,-10,10,-10); //definir volumen de trabajo plano en x y y
}
glBegin(GL_LINES);//trazo d linea
glVertex2f(0,0);//F flotante i entero

glVertex2f(0,9);//vertices de punto a punto
glVertex2f(0.5,-1);
glVertex2f(-1,0);
glVertex2f(-1,9);
glVertex2f(-1.5,0);
glVertex2f(-1.5,9);
glVertex2f(-2,0);
glVertex2f(-2,9);
glVertex2f(-3,0);
glVertex2f(-3,9);
glVertex2f(0,0);
glVertex2f(-3,9);
glVertex2f(-3,0);
glVertex2f(0,9);
glVertex2f(-3,0);
glVertex2f(0,0);
glVertex2f(-3,9);
glVertex2f(0,9);
glEnd();
glFlush();//termina
}
{
glutCreateWindow("PROFE ZARCO");//nombre ventana
glutMainLoop();
return 0;
}
17) #include <stdio.h>

#include <stdarg.h>
#include <math.h>
#define GL_GLEXT_PROTOTYPES
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#endif
// ---------------------------------------------------------// Prototipos de funcin

// ---------------------------------------------------------void display();
void specialKeys();
// ---------------------------------------------------------// Variables globales

// ---------------------------------------------------------double rotate_y=0;
double rotate_x=0;
// ---------------------------------------------------------// Funcin de retrollamada display()

// ---------------------------------------------------------void display(){
// Borrar pantalla y Z-buffer

// Resetear transformaciones
glLoadIdentity();
// Otras transformaciones
// glTranslatef( 0.1, 0.0, 0.0 );
// No incluido
// glRotatef( 180, 0.0, 1.0, 0.0 );
// No incluido
// Rotar cuando el usuario cambie rotate_x y rotate_y

glRotatef( rotate_y, 0.0, 1.0, 0.0 );
// Otras transformaciones
// glScalef( 2.0, 2.0, 0.0 );
// No incluido
//LADO FRONTAL: lado multicolor

glColor3f( 1.0, 0.0, 0.0 );
glVertex3f( 0.5, -0.5, -0.5 );
// P1 es rojo
glColor3f( 0.0, 1.0, 0.0 );
glVertex3f( 0.5, 0.5, -0.5 );
// P2 es verde
glColor3f( 0.0, 0.0, 1.0 );
glVertex3f( -0.5, 0.5, -0.5 );
// P3 es azul
glColor3f( 1.0, 0.0, 1.0 );
glVertex3f( -0.5, -0.5, -0.5 );
// P4 es morado
glEnd();
// LADO TRASERO: lado blanco

glColor3f( 1.0, 1.0, 1.0 );
glVertex3f( 0.5, -0.5, 0.5 );
glVertex3f( 0.5, 0.5, 0.5 );
glVertex3f( -0.5, 0.5, 0.5 );
glVertex3f( -0.5, -0.5, 0.5 );
glEnd();
// LADO DERECHO: lado morado

glColor3f( 1.0, 0.0, 1.0 );
glVertex3f( 0.5, -0.5, -0.5 );
glVertex3f( 0.5, 0.5, -0.5 );
glVertex3f( 0.5, 0.5, 0.5 );
glVertex3f( 0.5, -0.5, 0.5 );
glEnd();
// LADO IZQUIERDO: lado verde

glColor3f( 0.0, 1.0, 0.0 );
glVertex3f( -0.5, -0.5, 0.5 );

glVertex3f( -0.5, 0.5, 0.5 );
glVertex3f( -0.5, 0.5, -0.5 );
glVertex3f( -0.5, -0.5, -0.5 );
glEnd();
// LADO SUPERIOR: lado azul

glColor3f( 0.0, 0.0, 1.0 );
glVertex3f( 0.5, 0.5, 0.5 );
glVertex3f( 0.5, 0.5, -0.5 );
glVertex3f( -0.5, 0.5, -0.5 );
glVertex3f( -0.5, 0.5, 0.5 );
glEnd();
// LADO INFERIOR: lado rojo

glColor3f( 1.0, 0.0, 0.0 );
glVertex3f( 0.5, -0.5, -0.5 );
glVertex3f( 0.5, -0.5, 0.5 );
glVertex3f( -0.5, -0.5, 0.5 );
glVertex3f( -0.5, -0.5, -0.5 );
glEnd();
glFlush();
glutSwapBuffers();
// ---------------------------------------------------------// Funcin de retrollamada specialKeys()

// ---------------------------------------------------------void specialKeys( int key, int x, int y ) {
// Flecha derecha: aumentar rotacin 5 grados

rotate_y += 5;
// Flecha izquierda: disminuir rotacin 5 grados

rotate_y -= 5;

rotate_x += 5;

rotate_x -= 5;
// Solicitar actualizacin de visualizacin

// ---------------------------------------------------------// Funcin main()

// ---------------------------------------------------------int main(int argc, char* argv[]){
// Inicializar los parmetros GLUT y de usuario proceso

// Solicitar ventana con color real y doble buffer con Z-buffer

// Crear ventana
glutCreateWindow("Cubo con la funcin rotate");
// Habilitar la prueba de profundidad de Z-buffer

// Funciones de retrollamada
// Pasar el control de eventos a GLUT

glutMainLoop();
// Regresar al sistema operativo

return 0;
18) #include<windows.h>
#include<iostream>
#include <stdlib.h>
using namespace std;
void handleKeypress(unsigned char key, int x, int y)

{
switch(key)
{
case 27:
exit(0);
}
}
void initRendering()
{
}
void handleResize(int w,int h)

{
glLoadIdentity();
gluPerspective(45.0,(double)w/(double)h,1.0,200.0);
}
float _angle=0.0;
float _cameraangle=30.0;
void drawScene()
{
glLoadIdentity();
glRotatef(_cameraangle,0.0f,1.0f,0.0f); //rotate object by 30 degree with respect to y-axis
glPushMatrix();
glTranslatef(5.0f, -1.0f, 0.0f);
glScalef(2.0f,2.0f,2.0f);
glRotatef(_angle,1.0f,3.0f,2.0f); //rotating object continuously by 2 degree

glBegin(GL_QUADS);
glVertex3f(-0.7f,0.0f,0.0);
glVertex3f(0.7f,0.0f,0.0);
glVertex3f(0.5f,2.0f,0.0);
glVertex3f(-0.5f,2.0f,0.0);
glEnd();
glPopMatrix();
glutSwapBuffers();
}
void update(int value)
{
_angle+=2.0f;
if(_angle>360.f)
{
_angle-=360;
}
glutTimerFunc(25,update,0);
}
{
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
glutCreateWindow("rotate");
initRendering();
glutDisplayFunc(drawScene);
glutKeyboardFunc(handleKeypress);
glutReshapeFunc(handleResize);
glutTimerFunc(25,update,0);
//this call the function update in every 25 millsecond
//so value of angle of rotation change and object rotates continuously
glutMainLoop();
return 0;
}

Practicas Semestre

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Practicas Semestre

Diunggah oleh

Hak Cipta:

Format Tersedia

Ingeniera en Sistemas Computacionales

float x= 0; //variable declarada

float px=0, py=7.7, radio =4, calx, caly;

glColor3f(1.0, 1.0, 1.0);

for (double i=0.0; i<10; i+=0.001)

glColor3f(1.0, 1.0, 1.0);

void avanzar (int value)

int x=1, x2=1, y=1;

for (int j=0; j<=100000000;j++){}

glRotatef( rotate_x, 1.0, 0.0, 0.0 );

glClearColor (0.0f, 0.0f, 0.0f, 0.0f);

glVertex3f( 0.5, -0.5, -0.5 );

glColor3f( 0.0, 1.0, 0.0 );

glVertex3f( 0.5, 0.5, -0.5 );

glColor3f( 0.0, 0.0, 1.0 );

glVertex3f( -0.5, 0.5, -0.5 );

glColor3f( 1.0, 0.0, 1.0 );

glVertex3f( -0.5, -0.5, -0.5 );

void specialKeys( int key, int x, int y ) {

else if (key == GLUT_KEY_LEFT)

else if (key == GLUT_KEY_UP)

else if (key == GLUT_KEY_DOWN)

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

for (int j=0; j<=10000000;j++) {}

void dibujar(int w,int h)

float aspect = 1.0f;

// Flecha derecha: aumentar rotacin 5 grados

// Flecha izquierda: disminuir rotacin 5 grados

else if (key == GLUT_KEY_UP)

else if (key == GLUT_KEY_DOWN)

// Solicitar actualizacin de visualizacin

void onSize(int sx, int sy) {

10) #include <GL/glut.h>

//inicializo la fuente de luz y las demas variables

glLightfv (GL_LIGHT0, GL_AMBIENT, light_ambient);

//este objeto esta definido en GLUT

//intercambio los Buffers

// salgo si se preciona ESC

//que hacer en ausencia de entrada

int main(int argc, char** argv)

//inicializa la ventana en el modo Doble Buffer

//inicia el proceso de eventos

11) #include <GL/glut.h>

GLfloat anguloCuboX = 0.0f;

void reshape(int width, int height)

glOrtho(-4,4, -4, 4, 1, 10);

glVertex3f(-1.0f, -1.0f, 1.0f);

glColor3f(0.0f, 1.0f, 0.0f);

glVertex3f( 1.0f, -1.0f, -1.0f);

glColor3f(0.0f, 0.0f, 1.0f);

//cara lateral izq

glColor3f(1.0f, 1.0f, 0.0f);

//cara lateral dcha

glVertex3f(1.0f, -1.0f, 1.0f);

glVertex3f(-1.0f, 1.0f, 1.0f);

glColor3f(1.0f, 0.0f, 1.0f);

glVertex3f( 1.0f,-1.0f, -1.0f);

glTranslatef(0.0f, 0.0f, -5.0f);

glRotatef(anguloCuboX, 1.0f, 0.0f, 0.0f);

glTranslatef(0.0f, 0.0f, -5.0f);

glColor3f(1.0f, 1.0f, 1.0f);

void keyboard(unsigned char key, int x, int y)

case 27: // escape