martes, 23 de agosto de 2011

DevC portable con OpenGL::2.programar

| 2 Comments




Continuando , ya configuramos (  leer como configurar ) , ahora para programar ...












9. abre el devc, nuevo proyecto ene este icono , indicas el lugar de guardar y el nombre











10. propiedades de proyecto


11.parámetros o argumentos en otros , porque ? , pos no se


12.linkear , añadir librería


13. escoges la librerías, *.lib, solo son 4 , y van a destacar justo porqué están en mayúscula




Aceptar. 

**no siempre va aparecer en los links , lib/opengl..etc, depende de donde se allá guardado el proyecto , va aparecer la ruta

14.listo , ahora a escribir el código ,..hagamos una prueba
15. este es el código




//inicio de codigo
#include <stdlib.h>
#include<conio.h>
#include <gl/glut.h>
#include <math.h>

//permite ajustar la escala visual
double esc=0.3;
//guarda el angulo de rotacion del sol y los planetas
//azul, rojo y verde respectivamente
int velocidad=3;
double sol=0;
double azul=0;
double rojo=0;
double verde=0;
//guarda el angulo de traslacion de los planetas
//azul, rojo y verde respectivos
double tazul=0;
double tverde=0;
double trojo=0;
//guarda el sentido de la rotacion del sol y los
//planetas respectivos
static int sen1=1; //sol
static int senA=1; //azul
static int senR=1; //rojo 
static int senV=1; //verde 
//guarda el sentido de la traslacion del los
//planetas respectivos
static int senta=1; //azul
static int sentv=1; //rojo
static int sentr=1; //verde 

// para el elipse a es el radio del eje horizontal
// y b el del eje vertical el valor de c sera la distancia
// del foco al centro que sera calculado como: c=b-a

double a=4;
double b=5;

void dibu_sol()
{	glColor3f(1,1,0);
	glutWireSphere(0.75,20,20);
}
void dibu_verde()
{	glColor3f(0,1,0);
	glutWireSphere(0.2,10,10);
}
void dibu_azul()
{	glColor3f(0,0,1);
	glutWireSphere(0.2,10,10);
}
void dibu_rojo()
{	glColor3f(1,0,0);
	glutWireSphere(0.2,10,10);
}
void init(void)
{
	glClearColor(1,1,1,0);
	glShadeModel(GL_FLAT);
}

void objeto_geometrico(void)
{	glScalef(esc,esc,esc);//genera una escala de visualizacion
	//grafica al sol y sus movimientos
	glRotatef(sol,0,1,0);
		dibu_sol();
	glRotatef(-sol,0,1,0);
	//grafica al planeta azul y sus movimientos
	glRotatef(tazul,0,1,0);
	glTranslatef(-4,0,0);
		glRotatef(azul,0,1,0);
			dibu_azul();
		glRotatef(-azul,0,1,0);
	glTranslatef(4,0,0);
	glRotatef(-tazul,0,1,0);
	//grafica al planeta verde y sus movimientos
	glRotatef(tverde,0,0,1);
	glTranslatef(0,2.5,0);
		glRotatef(verde,0,1,0);
			dibu_verde();
		glRotatef(-verde,0,1,0);
	glTranslatef(0,-2.5,0);
	glRotatef(-tverde,0,0,1);
	//grafica al planeta rojo y sus movimientos
	glTranslatef(a*cos(trojo),b*sin(trojo),0);
		glTranslatef(0,b-a,0);
			glRotatef(rojo,0,1,0);
				dibu_rojo();
			glRotatef(rojo,0,1,0);
		glTranslatef(0,a-b,0);
	glTranslatef(-a*cos(trojo),-b*sin(trojo),0);
}

void display(void)
{	
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();
	glColor3f(1,1,1);
	//dibuja los ejes cordenados
	glBegin(GL_LINES);
		glVertex3f(0,0,0);
		glVertex3f(0,0,1.5);
		glVertex3f(0,0,0);
		glVertex3f(0,1.5,0);
		glVertex3f(0,0,0);
		glVertex3f(1.5,0,0);
	glEnd();
	objeto_geometrico ();
	glFlush();
	glutSwapBuffers();
}
//genera el momiento de rotacion del sol usando presisamente rotaciones
void girar_sol()
{
	sol +=0.7*sen1*velocidad;
	if(sol>360) sol -= 360.0;
	if(sol<0) sol += 360.0;
	display();
}
//genera el momiento de rotacion del planeta azul usando presisamente rotaciones
void girar_Azul()
{
	azul += 0.6*senA*velocidad;
	if(azul>360) azul -= 360.0;
	if(azul<0) azul += 360.0;
	display();
}
//genera el momiento de rotacion del planeta verde usando presisamente rotaciones
void girar_Verde()
{	verde += 0.6*senV*velocidad;
	if(verde>360) verde -= 360.0;
	if(verde<0) verde += 360.0;
	display();
}
//genera el momiento de rotacion del planeta rojo usando presisamente rotaciones
void girar_Rojo()
{	rojo += 0.6*senR*velocidad;
	if(rojo>360) rojo -= 360.0;
	if(rojo<0) rojo += 360.0;
	display();
}
//genera el momiento de rotacion del planeta azul usando rotaciones
void trans_azul()
{	tazul+=0.8*senta*velocidad;
    if(tazul>360) tazul -= 360.0;
	if(tazul<0) tazul += 360.0;
	display();
}
//genera el momiento de rotacion del planeta verde usando rotaciones
void trans_verde()
{	tverde+=0.8*sentv*velocidad;
    if(tverde>360) tverde -= 360.0;
	if(tverde<0) tverde += 360.0;
	display();
}
//genera el momiento de rotacion del planeta rojo usando transalaciones 
//adaptando la ecuacion de la circunferencia para el elipse
void trans_rojo()
{	trojo+=0.015*sentr*velocidad;
    if(trojo>360) trojo -= 360.0;
	if(trojo<-360) trojo += 360.0;
	display();
}
//permite cambiar el sentido de las rotaciones y translaciones
//de los planetas y el sol
void teclado(unsigned char tecla,int x,int y)
{
	switch(tecla)
	{	case 'q' :
		case 'Q' : sen1 = 1; break;
		case 'w' :
		case 'W' : sen1 = -1; break;
		case 'a' :
		case 'A' : senA=1;break;
		case 's' :
		case 'S' : senA=-1;break;
		case 'E' :
		case 'e' : senta=1;break;
		case 'r' :
		case 'R' : senta=-1;break;
		case 'O' :
		case 'o' : senV=1;break;
		case 'p' :
		case 'P' : senV=-1;break;
		case 'C' :
		case 'c' : sentv=1;break;
		case 'v' :
		case 'V' : sentv=-1;break;
		case 'z' :
		case 'Z' : senR=1;break;
		case 'X' :
		case 'x' : senR=-1;break;
		case 'D' :
		case 'd' : sentr=1;break;
		case 'F' :
		case 'f' : sentr=-1;break;
		case 'K' :
		case 'k' : exit(0) ;
	}
}


void myReshape(int w, int h)
{
	glViewport(0,0,w,h);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	if(w <=h)
	glOrtho(-2.0,2.0,-2.0*(GLdouble)h/(GLdouble)w,
	2.0*(GLdouble)h/(GLdouble)w, -10.0, 10.0);
	else
	glOrtho(-2.0*(GLdouble)w/(GLdouble)h,
	2.0*(GLdouble)w/(GLdouble)h, -2.0,2.0,-10.0,10.0);
	glMatrixMode(GL_MODELVIEW);
}

void menu1(int op)
{
 switch(op){
 case 1: sen1=1; break;
 case 2: sen1=-1; break;
 case 3: senA=1; break;
 case 4: senA=-1; break;
 case 5: senta=1; break;
 case 6: senta=-1; break;
 case 7 :senV=1; break;
 case 8: senV=-1; break;
 case 9: sentv=1; break;
 case 10:sentv=-1; break;
 case 11:senR=1; break;
 case 12:senR=-1; break;
 case 13:sentr=1 ; break;
 case 14 :sentr=-1 ; break;
 case 15 : exit(0); break;
 }
}

void inicio()
{	girar_sol();
	girar_Azul();
	trans_azul();
	girar_Verde();
	trans_verde();
	girar_Rojo();
	trans_rojo();
}

int main(int argc, char **argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
	glutInitWindowSize(600,600);
	glutCreateWindow("Sistema Planetario");
	glutDisplayFunc(display);
	glutIdleFunc(inicio);
    int submenu=glutCreateMenu(menu1);//de los modelos
	
    glutCreateMenu(menu1);
    glutAddSubMenu("Planetas",submenu);
        

    glutAddMenuEntry("Rotacion Sol antihoraria",1);
    glutAddMenuEntry("Rotacion Sol horaria",2);
	glutAddMenuEntry("Rotacion Azul antihoraria",3);
	glutAddMenuEntry("Rotacion Azul horaria",4);
    glutAddMenuEntry("Traslacion Azul antihoraria",5);
	glutAddMenuEntry("Traslacion Azul horaria",6);
	glutAddMenuEntry("Rotacion Verde antihoraria",7);
	glutAddMenuEntry("Rotacion Verde horaria",8);
	glutAddMenuEntry("Traslacion Verde antihoraria",9);
    glutAddMenuEntry("Traslacion Verde horaria",10);
	glutAddMenuEntry("Rotacion Rojo antihoraria",11);
	glutAddMenuEntry("Rotacion Rojo horaria",12);
    glutAddMenuEntry("Traslacion Rojo antihoraria",13);
	glutAddMenuEntry("Traslacion Rojo horaria",14);
	
	glutAddMenuEntry("Salir",15);

	glutAttachMenu(GLUT_RIGHT_BUTTON);
	glutReshapeFunc(myReshape);
	
	glutKeyboardFunc(teclado);
	glEnable(GL_DEPTH_TEST);
	glutMainLoop();

}

//fin de codigo


16. F9 , para compilar y ejecutar , come primera ves taímen te va pedir guardar , y ponerle un nombre ……, lito


17. Bien!!! si funciona .

Todo listo , ahora pueden llevárselo en usb y programar a gusto .
Tags : , , , ,

2 comentarios: