1. No category

INSTITUTO TECNOLOGICO
SUPERIOR DE ATLIXCO
INSTITUTO TECNOLOGICO SUPERIOR DE ATLIXCO
Introducción
A continuación, se crear y muestra el famoso cubo rubik con la ayuda de las
librerías opengl se graficará dicho cubo.
Ejecución del programa:
CONTENIDO
Condigo fuente de cubo:
#include "stdafx.h"
#include"GL/glut.h"
#include"stdio.h"
#define size 600
#define NEAR_Z 1.0
#define FEAR_Z 100.0
float X_angle, Y_angle, Z_angle;
typedef GLfloat point[4];
point pt[] = {
{ 6.0, 6.0, 0.0 },//v0
{ 6.0, -6.0, 0.0 },//v1
{ -6.0, -6.0, 0.0 },//v2
{ -6.0, 6.0, 0.0 },//v3
{ -2.0, 2.0, 0.0 },//v4
{ -2.0, 6.0, 0.0 },//v5
{ -6.0, 2.0, 0.0 },//v6
{ 2.0, 2.0, 0.0 },//v7
{ 2.0, 6.0, 0.0 },//v8
{ 6.0, 2.0, 0.0 },//v9
{ -6.0, -2.0, 0.0 },//v10
{ -2.0, -2.0, 0.0 },//v11
{ 2.0, -2.0, 0.0 },//v12
{ 6.0, -2.0, 0.0 },//v13
{ -2.0, -6.0, 0.0 },//v14
{ 2.0, -6.0, 0.0 },//v15
};:
typedef GLfloat COLOR[3];// hacemos referrecia a los colores
COLOR arrColor[]=
{
{ 1.0, 0.2, 0.1 },
{ 0.6, 0.1, 0.0 },
{ 0.4, 1.0, 0.3 },
{ 0.1, 0.0, 0.5 }
};
void dibujarLado(int v0, int v1, int v2, int v3, int iColor){
glColor3fv(arrColor[iColor]);
glBegin(GL_POLYGON);
glVertex3fv(pt[v0]);
glVertex3fv(pt[v1]);
glVertex3fv(pt[v2]);
glVertex3fv(pt[v3]);
glEnd();
}
void dibujarcub(void){
dibujarLado(12, 13, 1, 15, 3);dibujarLado(11, 12, 15, 14, 1);
dibujarLado(10, 11, 14, 2, 3);dibujarLado(7, 9, 13, 12, 1);
dibujarLado(4, 7, 12, 11, 3);dibujarLado(6, 4, 11, 10, 1);dibujarLado(8, 0,
9, 7, 3);
dibujarLado(5, 8, 7, 4, 1); dibujarLado(4, 6, 3, 5, 3);dibujarLado(0, 1, 2,
3, 1);
dibujarLado(0, 1, 2, 3, 3);
}
void Init(){
X_angle = 0.0;
Y_angle = 0.0;
Z_angle = 0.0;
glEnable(GL_DEPTH_TEST);
}
void reshapeProc(int a, int b){
glViewport(0, 0, a, b);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, GLfloat(a) / GLfloat(b), NEAR_Z, FEAR_Z);
glMatrixMode(GL_MODELVIEW);
}
void DisplayCallProc(void){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0, 0, -30);//se aleja la imagen
glRotated(X_angle, 1.0, 0.0, 0.0);
glRotated(Y_angle, 0.0, 1.0, 0.0);
glRotated(Z_angle, 0.0, 0.0, 1.0);
dibujarcubito();
glutSwapBuffers();
}
int main(int argc, char * argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(size, size);
glutInitWindowPosition(350, 200);
glutCreateWindow("Cubo Rubik");
Init();
glutDisplayFunc(DisplayCallProc);
glutReshapeFunc(reshapeProc);
glutMainLoop();
return(1);
}
COCLUSION:
el manejo delos vectores nos brinda mejores resultados con vemos en este código
que hemos desarrollado
INSTITUTO TECNOLOGICO SUPERIOR DE ATLIXCO
Introducción
El manejo de los vectores es de gran ayuda para la construcción de figuras
complejas como la pirámide que a continuación se grafica
Contenido
Ejecución de programa:
El código fuente:
#include "stdafx.h"
#include "GL/glut.h"
#include "stdio.h"
#define size 400
#define NEAR_Z 1.0
#define FEAR_Z 0.0
float X_angle, Y_angle, Z_angle;
typedef GLfloat point[3];
point pt[] = {
{
{
{
{
0.0, 3.0, 0.0 }, //v0
3.0, -3.0, 0.0 },//V1
-3.0, -3.0, 0.0 },//V2
0.0, 0.0, 3.0 }//V3
};
typedef GLfloat Color[3];
Color arrColor[] = {
{ 1.0, 0.0, 1.0 },//color
{ 0.0, 1.0, 0.0 },//color
{ 1.0, 1.0, 1.0 },//color
{ 1.0, 0.0, 1.0 }//color
};
void Dibujaladopiramide(int V0, int V1, int V2, int iColor)
{
glColor3fv(arrColor[iColor]);
glBegin(GL_POLYGON);
glVertex3fv(pt[V0]);
glVertex3fv(pt[V1]);
glVertex3fv(pt[V2]);
glEnd();
}
void DibujaPiramide(void){
Dibujaladopiramide(0, 1,
Dibujaladopiramide(0, 1,
Dibujaladopiramide(1, 2,
Dibujaladopiramide(0, 1,
//Dibujaladopiramide()
3,
3,
3,
2,
0);
2);
2);
1);
}
void Init()
{
X_angle = 0.0;
Y_angle = 0.0;
Z_angle = 0.0;//
glEnable(GL_DEPTH_TEST);
}
void reshapeProc(int w, int h){
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, GLfloat(w) / GLfloat(h), NEAR_Z, FEAR_Z)
glMatrixMode(GL_MODELVIEW);
}
void DisplayCallProc(void){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0, 0, -10);
glRotatef(X_angle, 1.0, 0.0, 0.0);
glRotatef(Y_angle, 0.0, 1.0, 0.0);
glRotatef(Z_angle, 0.0, 0.0, 1.0);
DibujaPiramide();
glutSwapBuffers();
}
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(size, size);
glutInitWindowPosition(350, 200);
glutCreateWindow("Piramide en 3D");
Init();
glutDisplayFunc(DisplayCallProc);
glutReshapeFunc(reshapeProc);
glutMainLoop();
return(1);
}
Conclusión:
Como pudimos ver es muy practico el uso delos vectores para definir figuras solo
que al principio cuesta un poco comprender su funcionamiento pero con el tiempo
y la practica esto ira mejorando.
Materia: Graficacion
Reporte de practica: Cubo Rubik
Alumno: Gabriel Romero Cuauhitzo
Semestre: 6ª A
Introducción
La presente practica es de la materia de graficacion en
ella se realiza un cubo rubik 3D utilizando las librerías
de opengl enseguida se redacta se muestra el código.
Contenido
Código de cubo
#include
#define
#include
#include
#include
"math.h"
GL_GLEXT_PROTOTYPES
"stdafx.h"
"GL/glut.h"
"stdio.h"
# define size 400
# define NEAR_z 1.0
# define FEAR_Z 100.0
void Display();
void specialkeys();
float x_angle, y_angle, z_angle;
typedef GLfloat Point[3];
Point pt[] = {
{
{
{
{
3, 3, 3 },//v0
3, -3, 3 },//v1
-3, -3, 3 },//v2
-3, 3, 3 }, //V3
{ -1, 3, 3 },//v4
{ -1, 1, 3 },//v5
{ -3, 1, 3 }, //v6
{ 1, 3, 3 }, //v7
{ 1, 1, 3 },//v8
{ 3, 1, 3 }, //v9
{ -1, -1, 3 },//10
{ -3, -1, 3 },//v11
{ 1, -1, 3 },//v12
{ 3, -1, 3 },//v13
{ -1, -3, 3 },//v14
{ 1, -3, 3 }, //v15
//cubo en la parte de atras
{
{
{
{
3, 3, -3 },//v16
3, -3, -3 },//v17
-3, -3, -3 },//v18
-3, 3, -3 }, //V19
{ -1, 3, -3 },//v20
{ -1, 1, -3 },//v21
{ -3, 1, -3 }, //v22
{ 1, 3, -3 }, //v23
{ 1, 1, -3 },//v24
{ 3, 1, -3 }, //v25
{ -1, -1, -3 },//26
{ -3, -1, -3 },//v27
{ 1, -1, -3 },//v28
{ 3, -1, -3 },//v29
{ -1, -3, -3 },//v30
{ 1, -3, -3 },//v31
//cubo de lado derecho
{ 3, 3, 1 },//32
{ 3, 1, 1 },//33
{ 3, 1, -1 },//34
{ 3, 3, -1 },//35
{ 3, 1, -3 },//36
{ 3, -1, -3 },//37
{ 3, -1, -1 },//38
{ 3, -1, 1 },//39
{ 3, -3, 1 },//40
{ 3, -3, -1 },//41
//Cubo lado izquiero
{ -3, 3, 1 },//42
{ -3, 1, 1 },//43
{ -3, 1, -1 },//44
{ -3, 3, -1 },//45
{ -3, -1, -1 },//46
{ -3, -1, 1 },//47
{ -3, -3, 1 },//48
{ -3, -3, -1 },//49
//cubo abajo
{ 1, -3, 1 },//50
{ -1, -3, 1 },//51
{ -1, -3, -1 },//52
{ 1, -3, -1 },//53
//cubo arriba
{ 1, 3, 1 },//54
{ -1, 3, 1 },//55
{ -1, 3, -1 },//56
{ 1, 3, -1 }//57
};
typedef GLfloat
COLOR arrColor[]
{ 1, 0, 1
{ 1, 0, 0
{ 0, 1, 0
{ 1, 1, 1
{ 1, 1, 0
{ 1, 0.5,
{ 0, 0, 1
};
COLOR[3]; //declara otro vector para definir colores de tipo RGB
= {
},//fiu
},//rojo
},//verde
},//blanco
},//Amarillo
0 },//naranja
} //azul
void DibujLadoCubo(int V0, int V1, int V2, int V3, int iColor)
{
glColor3fv(arrColor[iColor]);
glBegin(GL_POLYGON);
glVertex3fv(pt[V0]);
glVertex3fv(pt[V1]);
glVertex3fv(pt[V2]);
glVertex3fv(pt[V3]);
glEnd();
}
void specialkeys(int key, int x, int y) {
if (key == GLUT_KEY_RIGHT)
y_angle += 5;
else if (key == GLUT_KEY_LEFT)
y_angle -= 5;
else if (key == GLUT_KEY_UP)
x_angle += 5;
else if (key == GLUT_KEY_DOWN)
x_angle -= 5;
glutPostRedisplay();
}
void DibujaCubo(void)
{
DibujLadoCubo(12, 13, 1, 15, 4);
DibujLadoCubo(14, 15, 12, 10, 3);
DibujLadoCubo(11, 10, 14, 2, 2);
DibujLadoCubo(8, 12, 13, 9, 6);
DibujLadoCubo(5, 10, 12, 8, 5);
DibujLadoCubo(6, 11, 10, 5, 4);
DibujLadoCubo(7, 8, 9, 0, 3);
DibujLadoCubo(4, 5, 8, 7, 2);
DibujLadoCubo(6, 5, 4, 3, 1);
//DibujLadoCubo(0,1,2,3,0); //cuadro principal
//cubo en la parte de atras
DibujLadoCubo(28, 29, 17, 31, 4);
DibujLadoCubo(30, 31, 28, 26, 3);
DibujLadoCubo(27, 26, 30, 18, 2);
DibujLadoCubo(24, 28, 29, 25, 6);
DibujLadoCubo(21, 26, 28, 24, 5);
DibujLadoCubo(22, 27, 26, 21, 4);
DibujLadoCubo(23, 24, 25, 16, 3);
DibujLadoCubo(20, 21, 24, 23, 2);
DibujLadoCubo(22, 21, 20, 19, 1);
//DibujLadoCubo(16,17,18,19,0);//cubo 2
//cara derecha
DibujLadoCubo(38, 41, 17, 37, 3);
DibujLadoCubo(39, 40, 41, 38, 2);
DibujLadoCubo(13, 1, 40, 39, 1);
DibujLadoCubo(9, 13, 39, 33, 6);
DibujLadoCubo(34, 38, 39, 33, 5);
DibujLadoCubo(36, 37, 38, 34, 4);
DibujLadoCubo(35, 34, 36, 16, 3);
DibujLadoCubo(32, 33, 34, 35, 2);
DibujLadoCubo(0, 32, 33, 9, 1);
//DibujLadoCubo(16,0,1,17,0);
//Cara Izquierda
DibujLadoCubo(46, 49, 18, 27, 3);
DibujLadoCubo(47, 48, 49, 46, 2);
DibujLadoCubo(11, 2, 48, 47, 1);
DibujLadoCubo(43, 47, 11, 6, 6);
DibujLadoCubo(44, 46, 47, 43, 5);
DibujLadoCubo(22, 27, 46, 44, 4);
DibujLadoCubo(19, 22, 44, 45, 3);
DibujLadoCubo(42, 43, 44, 45, 2);
DibujLadoCubo(3, 6, 43, 42, 1);
//DibujLadoCubo(19,3,2,18,0);
//parte base
DibujLadoCubo(30, 52, 49, 18, 3);
DibujLadoCubo(31, 53, 52, 30, 2);
DibujLadoCubo(17, 41, 53, 31, 1);
DibujLadoCubo(53, 50, 40, 41, 6);
DibujLadoCubo(52, 51, 50, 53, 5);
DibujLadoCubo(49, 48, 51, 52, 4);
DibujLadoCubo(51, 14, 2, 48, 3);
DibujLadoCubo(50, 15, 14, 51, 2);
DibujLadoCubo(40, 1, 15, 50, 1);
//DibujLadoCubo(17,1,2,18,0);
//Parte de arriba
DibujLadoCubo(20,
DibujLadoCubo(23,
DibujLadoCubo(16,
DibujLadoCubo(57,
DibujLadoCubo(56,
DibujLadoCubo(45,
DibujLadoCubo(55,
56, 45, 19, 6);
57, 56, 20, 2);
35, 57, 23, 1);
54, 32, 35, 6);
55, 54, 57, 4);
42, 55, 56, 5);
4, 3, 42, 2);
DibujLadoCubo(54, 7, 4, 55, 1);
DibujLadoCubo(32, 0, 7, 54, 3);
//DibujLadoCubo(3,0,16,19,0);
}
void Init()
{
x_angle = 0.0f;
y_angle = 0.0f;
z_angle = 0.0f;
glEnable(GL_DEPTH_TEST);
}
void reshapeProc(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, GLfloat(w) / GLfloat(h), NEAR_z, FEAR_Z);
glMatrixMode(GL_MODELVIEW);
}
void DisplayCallProc(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0, 0, -10);
glRotatef(x_angle, 1.0, 0.0, 0.0);
glRotatef(y_angle, 0.0, 1.0, 0.0);
glRotatef(z_angle, 0.0, 0.0, 1.0);
DibujaCubo();
glutSwapBuffers();
}
int main(int argc, char * argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(size, size);
glutInitWindowPosition(350, 200);
glutCreateWindow("Cubo de Rubik");
Init();
glutDisplayFunc(DisplayCallProc);
glutReshapeFunc(reshapeProc);
glutSpecialFunc(specialkeys);
glutMainLoop();
return(1);
}
Compilación de código:
Conclusión
Es bueno realizar este tipo de ejercicios porque así
comprendemos más los entornos gráficos 3D, como
también nos motiva a tener curiosidad por este tipo de
figuras 3D
Cubo Ejemplo de clase de Graficacion previo a Bob
Esponja
Código documentado de cubo muestra
#include "stdafx.h"
#include "GL/glut.h"
#include "stdio.h"
# define size 400 //Define la variable
# define NEAR_z 1.0 //
# define FEAR_Z 100.0
float x_angle, y_angle, z_angle; //variables de tipo flotante para poder rotar la
`proyeccion
typedef GLfloat Point[3]; //declarar un objeto con tres posiciones
Point pt[] = {
//declaran cuatro puntos
{ 3, 3, 0 },//v0
{ 3, -3, 0 },//v1
{ -3, -3, 0 },//v2
{ -3, 3, 0 }, //V3
{ -1, 3, 0 },//v4
{ -1, 1, 0 },//v5
{ -3, 1, 0 }, //v6
{ 1, 3, 0 }, //v7
{ 1, 1, 0 },//v8
{ 3, 1, 0 }, //v9
{ -1, -1, 0 },//10
{ -3, -1, 0 },//v11
{ 1, -1, 0 }//v12
};
typedef GLfloat COLOR[3]; //declara otro vector para definir colores de tipo RGB
COLOR arrColor[] = {
{ 1.0, 0.0, 1.0 },//fiu
{ 0.0, 1.0, 1.0 },//acua
{ 1.0, 1.0, 1.0 },//fiu
{ 1.0, 0.0, 1.0 }//blanco
};
void DibujLadoCubo(int V0, int V1, int V2, int V3, int
arreglos con 4 valores de entrada de tipo entero
{
glColor3fv(arrColor[iColor]); // mandar a traer
glBegin(GL_POLYGON);//mandar a traer la palabra
el poligono
glVertex3fv(pt[V0]); //mandar a traer cada uno
del objeto
glVertex3fv(pt[V1]);
glVertex3fv(pt[V2]);
iColor)
//manda a traer los
el color
reservada para poder generar
de los puntos con el nombre
glVertex3fv(pt[V3]);
glEnd();
}
void DibujaCubo(void) //crear un nuevo metodo para dibujar la piramide
{
DibujLadoCubo(6, 11, 10, 5, 1);
DibujLadoCubo(7, 8, 9, 0, 2);
DibujLadoCubo(4, 5, 8, 7, 1);
DibujLadoCubo(6, 5, 4, 3, 2);
DibujLadoCubo(0, 1, 2, 3, 0); //cuadro principal
}
void Init()//este metodo nos permite inicializar las variables en cero tanto en x,y
y z
{
x_angle = 0.0f;
y_angle = 0.0f;
z_angle = 0.0f;
glEnable(GL_DEPTH_TEST); //Activa el buffer de profundidad
}
void reshapeProc(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, GLfloat(w) / GLfloat(h), NEAR_z, FEAR_Z);
glMatrixMode(GL_MODELVIEW);
}
void DisplayCallProc(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0, 0, -10);
glRotatef(x_angle, 1.0, 0.0, 0.0);
glRotatef(y_angle, 0.0, 1.0, 0.0);
glRotatef(z_angle, 0.0, 0.0, 1.0);
DibujaCubo();
glutSwapBuffers();
}
int main(int argc, char * argv[]) //manadar a traer las variables para dibujar la
figura en el monitor
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(size, size); //mandar a traer la variable size para poder
generar el tamaño
glutInitWindowPosition(350, 200); //la posicion en la que se va a encontrar
la ventana
glutCreateWindow("cubo"); //crea la ventana
Init();
glutDisplayFunc(DisplayCallProc); //generar la interfaz
glutReshapeFunc(reshapeProc);//permite dibujar lo que se a generado
glutMainLoop();
return(1); //retorna uno para verificar si funciona
}
Compilación de código:
INSTITUTO TECNOLOGICO SUPERIOR DE ATLIXCO
Proyecto: BobSponja 3D
Alumno: Gabriel Romero Cuauhitzo
Materia Graficacion
Semestre: 6º A
Parcial: 3
Corrida de proyecto BobSponja
Código de proyecto:
#include "stdafx.h"
#include <GL/glut.h>
#include <stdio.h>
#define SIZE 400
#define NEAR_Z 1.0
#define FAR_Z 100.0
#define GL_PI 3.1415f
#include "math.h"
int is_depth;
GLfloat angulo=0,xrot=1,yrot=1,angulox=0,anguloy=0;
float x_angle, y_angle, z_angle;
typedef GLfloat Point[3];
int ancho=SIZE, alto=SIZE;
GLfloat x,y,z,angle;
Point pt[]={
{-4,-2,1},//vo
{4,-2,1},//v1
{4,8,1},//v2
{-4,8,1},//v3
{-4,-2,-1},//v4
{4,-2,-1},//v5
{4,8,-1},//v6
{-4,8,-1},//v7
{-4,-3,1},//v8
{4,-3,1},//9
{-4,-3,-1},//v10
{4,-3,-1},//11
//
{-4,-6,1},//12
{4,-6,1},//13
{-4,-6,-1},//14
{4,-6,-1},//15
//
{1,3,1},//vector 16
{3,3,1},//17
{3,6,1},//18
{1,6,1},//19
//ojo de adentro
{1.5,3.5,1},//20
{2.5,3.5,1},//21
{2.5,5.5,1},//22
{1.5,5.5,1},//23
//
{1.7,3.7,1},//24
{2.3,3.7,1},//25
{2.3,5.3,1},//26
{1.7,5.3,1},//27
{-1,3,1},//vector 28
{-3,3,1},//29
{-3,6,1},//30
{-1,6,1},//31
//ojo de adentro
{-1.5,3.5,1},//32
{-2.5,3.5,1},//33
{-2.5,5.5,1},//34
{-1.5,5.5,1},//35
{-1.7,3.7,1},//36
{-2.3,3.7,1},//37
{-2.3,5.3,1},//38
{-1.7,5.3,1},//39
//BLACK MOUTH
{-2,0.5,1},//40
{2,0.5,1},//41
{2,2,1},//42
{-2,2,1},//43
//DIENTE DERE
{0.2,1,1},//44
{1.5,1,1},//45
{1.5,2,1},//46
{0.2,2,1},//47
//DIENTE IZQUI
{-0.2,1,1},//48
{-1.5,1,1},//49
{-1.5,2,1},//50
{-0.2,2,1},//51
//manga blanca lado izq
{-6,2,1},//52
{-4,2,1},//53
{-4,4,1},//54
{-6,4,1},//55
//atras
{-6,2,-1},//56
{-4,2,-1},//57
{-4,4,-1},//58
{-6,4,-1},//59
//manga derecha
{6,2,1},//60
{4,2,1},//61
{4,4,1},//62
{6,4,1},//63
//babk
{6,2,-1},//64
{4,2,-1},//65
{4,4,-1},//66
{6,4,-1},//67
//
{-2.8,6,1},//68
{-2.6,6,1},//69
{-2.6,6.5,1},//70
{-2.8,6.5,1},//71
///////////////
{-2.2,6,1},//72
{-2,6,1},//73
{-2,6.5,1},//74
{-2.2,6.5,1},//75
//////////////
{-1.8,6,1},//76
{-1.6,6,1},//77
{-1.6,6.5,1},//78
{-1.8,6.5,1},//79
//ojo lado derecho
{2.8,6,1},//80
{2.6,6,1},//81
{2.6,6.5,1},//82
{2.8,6.5,1},//83
//
{2.2,6,1},//84
{2,6,1},//85
{2,6.5,1},//86
{2.2,6.5,1},//87
//
{1.8,6,1},//88
{1.6,6,1},//89
{1.6,6.5,1},//90
{1.8,6.5,1},//91
//brazo derecho
{4.5,-3,1},//92
{6,-3,1},//93
{6,2,1},//94
{4.5,2,1},//95
//back side
{4.5,-3,-1},//96
{6,-3,-1},//97
{6,2,-1},//98
{4.5,2,-1},//99
//opisite
{-4.5,-3,1},//100
{-6,-3,1},//101
{-6,2,1},//102
{-4.5,2,1},//103
//back side
{-4.5,-3,-1},//104
{-6,-3,-1},//105
{-6,2,-1},//106
{-4.5,2,-1},//107
{-1,-4,1},//108
{1,-4,1},//9
{1,-3,1},//10
{-1,-3,1},//11
{-2,-10,1},//13
{-1,-10,1},//12
{-1,-5,1},//14
{-2,-5,1},//15
{-2,-10,-1},//16
{-1,-10,-1},//17
{-1,-5,-1},//18
{-2,-5,-1},//19
//////////////////
{2,-10,1},//20
{1,-10,1},//21
{1,-5,1},//22
{2,-5,1},//23
};
typedef GLfloat COLOR[3];//colores
COLOR arrColor[]={
{1.1,1.1,0},//amaril
{1,1,1},//blanco
{0.33,0.21,0.10},//cafe
{0,0,0},//negro
{0.0,1.0,1.0},//azul
{1,0,0}//rojo
};
void DibujarLado(int v0, int v1, int v2, int v3, int iColor)
{
glColor3fv(arrColor[iColor]);
glBegin(GL_POLYGON);
glVertex3fv(pt[v0]);
glVertex3fv(pt[v1]);
glVertex3fv(pt[v2]);
glVertex3fv(pt[v3]);
glEnd();
}
void DibujaCubo (void)
{
DibujarLado(120,121,122,123,0);
DibujarLado(116,117,118,116,0);
DibujarLado(112,113,114,115,0);
DibujarLado(105,106,107,108,0);
DibujarLado(101,102,103,104,0);
DibujarLado(92,96,99,95,0);
DibujarLado(92,93,94,95,0);
DibujarLado(96,97,98,99,0);
DibujarLado(93,97,94,98,0);
//
//brazo de bob
DibujarLado(64,65,66,67,1);//back manga
DibujarLado(60,64,67,63,1);//
DibujarLado(60,61,62,63,1);//front manga
//manga de bobesponja
DibujarLado(52,56,59,55,1);//LADO DE MANGA
DibujarLado(56,57,58,59,1);//...parte de atras
DibujarLado(52,53,54,55,1);//...parte frontal
//PANTALON CAFE
DibujarLado(8,12,14,4,2);//lado izquierdo
DibujarLado(9,13,15,5,2);//lado derecho de pantslon cafe
DibujarLado(4,14,15,5,2);//lado de atras dl pantaloncafe
DibujarLado(8,12,13,9,2);//parte frontal cafe
//camisa blanca
DibujarLado(0,8,10,4,1);//parte izquierdablanca
DibujarLado(1,9,11,5,1);//pasrte derecha camisa blanca
DibujarLado(4,10,11,5,1);//parte atras camisa blanca
DibujarLado(0,8,9,1,1);//camisa blanca frontal
//CUERPO DE BOBESPONJA
DibujarLado(0,3,7,4,0); //izquierdo
DibujarLado(1,2,6,5,0);//derecho
DibujarLado(4,5,6,7,0);//atras
DibujarLado(0,1,2,3,0);//fontal
//brazo
//OJOS DE BOBESPONJA
DibujarLado(16,17,18,19,1);//ojo blanco
DibujarLado(20,21,22,23,4);//ojo azul
DibujarLado(24,25,26,27,3);
DibujarLado(28,29,30,31,1);//oko blanko izquierdo
DibujarLado(32,33,34,35,4);//azul de ojo izq.
DibujarLado(36,37,38,39,3);//parte negra de ojo izq.
//BOCA
DibujarLado(40,41,42,43,3);
//DIENTE
DibujarLado(44,45,46,47,1);//
DibujarLado(48,49,50,51,1);
//pestaña
DibujarLado(68,69,70,71,3);
DibujarLado(72,73,74,75,3);
DibujarLado(76,77,78,79,3);
DibujarLado(80,81,82,83,3);
DibujarLado(84,85,86,87,3);
DibujarLado(88,89,90,91,3);
////////////////////
DibujarLado(108,109,110,111,5);
}
void ejes()
{
glColor3f(0.9, 0.9, 0.9);
glBegin(GL_LINES);
glVertex3f(-ancho/2, 0, 0);
glVertex3f(ancho/2, 0, 0);
glVertex3f(0, alto/2, 0);
glVertex3f(0, -alto/2, 0);
glEnd();
}
void Display(void)
{
if(is_depth)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);glBegin(GL_QUADS);
glColor3f(0.2f,0.2f,0.2f);
glVertex3f(-100.0,0.0,-100.0);
glColor3f(0.4f,0.4f,0.4f);
glVertex3f(-100.0,0.0,100.0);
glColor3f(0.6f,0.6f,0.6f);
glVertex3f(100.0,0.0,100.0);
glColor3f(0.8f,0.8f,0.8f);
glVertex3f(100.0,0.0,-100.0);
}
else
glClear(GL_COLOR_BUFFER_BIT );
DibujaCubo();
ejes();
glutSwapBuffers();
}
void reShapeProc(int w, int h)
{
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective (60.0,GLfloat(w)/GLfloat(h), NEAR_Z, FAR_Z);
glMatrixMode(GL_MODELVIEW);
}
void DisplayCallProc(void)
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0,0,-10);
ejes();
DibujaCubo();
glutSwapBuffers();
}
void Keyboard(unsigned char key,int x,int y)
{
switch(key)
{
case 'x': case 'X': glRotatef(10,1.0,0.0,0.0);
break;
case 'y': case 'Y': glRotatef(10,0.0,1.0,0.0);
break;
case 'z': case 'Z': glRotatef(10,0.0,0.0,1.0);
break;
case 'c': case 'C': glTranslatef(0.0,0.0,-5.0);
break;
case 'l': case 'L': glTranslatef(0.0,0.0,5.0);
break;
}
Display();
}
void main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(SIZE,SIZE);
glutInitWindowPosition(350,200);
glutCreateWindow("bob sponja");
glutDisplayFunc(DisplayCallProc);
glutKeyboardFunc(Keyboard);
glutReshapeFunc(reShapeProc);
glutMainLoop();
}