Práctica 9

3.-Tome el programa flag y modifiquelo para:

-La superficie conste ahora de 4 paredes
Aplique deformaciones que parezcan oleaje:

-La letra A incremente la amplitud de la deformación
-La letra a decremente la amplitud de la deformación
-La letra F aumenta la frecuencia
-La letra f disminuye la frecuencia

# include
# include
# include
# include
# define PI 3.1415926535

GLfloat ctlpoints1[4][4][3];
GLfloat ctlpoints2[4][4][3];
GLfloat ctlpoints3[4][4][3];
GLfloat ctlpoints4[4][4][3];

GLfloat *grid1=&ctlpoints1[0][0][0];
GLfloat *grid2=&ctlpoints2[0][0][0];
GLfloat *grid3=&ctlpoints3[0][0][0];
GLfloat *grid4=&ctlpoints4[0][0][0];
GLfloat modo=GLU_FILL;
GLfloat luz_ambiental[4]={1.0,1.0,1.0,1.0};

static float tex[2][2][2] = { { {0, 0}, {1, 0} }, { {0, 1}, {1, 1} } };

GLfloat amplitud = 2.0;
static float iteracion = 0.01;
static float fase = 0.0;
static float time = 0.0;
int window;
int showPoints=0;
int winWidth, winHeight;
int uSize = 4;
int vSize = 4;
int textura = 0;
static int angx = 0;
static int angy=0;
static int angz=0;
static GLfloat x=0.0;
static GLfloat y=0.0;
static GLfloat z=0.0;
static float ang=0.0;

GLUnurbsObj *objNurb1;
GLUnurbsObj *objNurb2;
GLUnurbsObj *objNurb3;
GLUnurbsObj *objNurb4;

void init_surface(void){
int u,v;
glPushAttrib(GL_ENABLE_BIT | GL_EVAL_BIT);
glEnable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
glEnable(GL_MAP2_VERTEX_3);
glEnable(GL_MAP2_TEXTURE_COORD_2);

for (u=0;u for (v=0;v {
ctlpoints1[u][v][0] = 2.0*((GLfloat)u) - 6.0;
ctlpoints1[u][v][1] = 2.0*((GLfloat)v);
ctlpoints1[u][v][2] = 0.0;
ctlpoints2[u][v][0] = 2.0*((GLfloat)u);
ctlpoints2[u][v][1] = 2.0*((GLfloat)v);
ctlpoints2[u][v][2] = 0.0;
ctlpoints3[u][v][0] = 2.0*((GLfloat)u) - 6.0;
ctlpoints3[u][v][1] = 2.0*((GLfloat)v) - 5.8;
ctlpoints3[u][v][2] = 0.0;
ctlpoints4[u][v][0] = 2.0*((GLfloat)u);
ctlpoints4[u][v][1] = 2.0*((GLfloat)v) - 5.8;
ctlpoints4[u][v][2] = 0.0;
}
}}
void init(void){
GLfloat mat_diffuse[] = {0.7,0.7,0.7,1.0};
GLfloat mat_specular[] = {1.0,1.0,1.0,1.0};
GLfloat mat_shininess[] = {100.0};
glClearColor(0.0,1.0,0.0,0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glLightfv(GL_LIGHT0,GL_AMBIENT,luz_ambiental);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
init_surface();
objNurb1=gluNewNurbsRenderer();
objNurb2=gluNewNurbsRenderer();
objNurb3=gluNewNurbsRenderer();
objNurb4=gluNewNurbsRenderer();
gluNurbsProperty(objNurb1, GLU_SAMPLING_TOLERANCE, 10.0);
gluNurbsProperty(objNurb1, GLU_DISPLAY_MODE, modo);
gluNurbsProperty(objNurb2, GLU_SAMPLING_TOLERANCE, 10.0);
gluNurbsProperty(objNurb2, GLU_DISPLAY_MODE, modo);
gluNurbsProperty(objNurb3, GLU_SAMPLING_TOLERANCE, 10.0);
gluNurbsProperty(objNurb3, GLU_DISPLAY_MODE, modo);
gluNurbsProperty(objNurb4, GLU_SAMPLING_TOLERANCE, 10.0);
gluNurbsProperty(objNurb4, GLU_DISPLAY_MODE, modo);
}
void showcontrolpoints(void){
int i;
glPointSize(5.0);
glDisable(GL_LIGHTING);
glColor3f(1.0,1.0,0.0);
for(i=0;i glBegin(GL_POINTS);
if (i == 0) glTexCoord2f(0.0,0.0);
if (i == 12) glTexCoord2f(1.0,0.0);
glVertex3fv(&grid1[i*3]);
if (i == 3) glTexCoord2f(0.0,1.0);
if (i == 15) glTexCoord2f(1.0,1.0);
glVertex3fv(&grid2[i*3]);
if (i == 0) glTexCoord2f(0.0,0.0);
if (i == 12) glTexCoord2f(1.0,0.0);
glVertex3fv(&grid3[i*3]);
if (i == 3) glTexCoord2f(0.0,1.0);
if (i == 15) glTexCoord2f(1.0,1.0);
glVertex3fv(&grid4[i*3]);
glEnd();
}
glEnable(GL_LIGHTING);
}
void senoidal(void){
int u, v;
iteracion = iteracion + time;
for (u = 0; u < uSize; u++){
for (v = 0; v < vSize; v++){
ctlpoints1[u][v][2] = amplitud * sin(u*(2*PI/8) + iteracion + v );
ctlpoints2[u][v][2] = amplitud * sin((u+3)*(2*PI/8) + iteracion + v);
ctlpoints3[u][v][2] = amplitud * sin(u*(2*PI/8) + iteracion + (2*v));
ctlpoints4[u][v][2] = amplitud * sin((u+3)*(2*PI/8) + iteracion + (2*v));
}}}
void display(void){
GLfloat knots1[8] = {0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0};
GLfloat knots2[8] = {0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0};
GLfloat knots3[8] = {0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0};
GLfloat knots4[8] = {0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0};
senoidal();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
gluNurbsProperty(objNurb1, GLU_DISPLAY_MODE, GLU_OUTLINE_POLYGON);
gluNurbsProperty(objNurb2, GLU_DISPLAY_MODE, GLU_OUTLINE_POLYGON);
gluNurbsProperty(objNurb3, GLU_DISPLAY_MODE, GLU_OUTLINE_POLYGON);
gluNurbsProperty(objNurb4, GLU_DISPLAY_MODE, GLU_OUTLINE_POLYGON);
glPushMatrix();
glRotatef((GLfloat)angx,1.0,0.0,0.0);
glRotatef((GLfloat)angy,0.0,1.0,0.0);
glRotatef((GLfloat)angz,0.0,0.0,1.0);
glTranslatef(x,0.0,0.0);
glTranslatef(0.0,y,0.0);
glTranslatef(0.0,0.0,z);
gluBeginSurface(objNurb1);
gluNurbsSurface(objNurb1, 8,knots1,8,knots1,4*3,3,grid1,4,4,GL_MAP2_VERTEX_3);
gluEndSurface(objNurb1);
gluBeginSurface(objNurb2);
gluNurbsSurface(objNurb2, 8,knots2,8,knots2,4*3,3,grid2,4,4,GL_MAP2_VERTEX_3);
gluEndSurface(objNurb2);
gluBeginSurface(objNurb3);
gluNurbsSurface(objNurb3, 8,knots3,8,knots3,4*3,3,grid3,4,4,GL_MAP2_VERTEX_3);
gluEndSurface(objNurb3);
gluBeginSurface(objNurb4);
gluNurbsSurface(objNurb4, 8,knots4,8,knots4,4*3,3,grid4,4,4,GL_MAP2_VERTEX_3);
gluEndSurface(objNurb4);
showcontrolpoints();
glPopMatrix();
glFlush();
glutSwapBuffers();
}
void keyboard(unsigned char key, int x, int y){
switch (key)
{
case 'm':
case 'M':
if (textura==0) {textura = 1; glEnable(GL_TEXTURE_2D);}
else {textura = 0; glDisable(GL_TEXTURE_2D);}
case 'A':
amplitud = amplitud + 0.1;
glutPostRedisplay();
break;
case 'a':
amplitud = amplitud - 0.1;
glutPostRedisplay();
break;
case 'F':
time = time + 0.01;
glutPostRedisplay();
break;
case 'f':
time = time - 0.01;
glutPostRedisplay();
break;
case 'p':

glutPostRedisplay();
break;
case 'P':

glutPostRedisplay();
break;
case 'x':
angx=(angx+10)%360;
glutPostRedisplay();
break;
case 'X':
angx=(angx-10)%360;
glutPostRedisplay();
break;
case 'y':
angy=(angy+10)%360;
glutPostRedisplay();
break;
case 'Y':
angy=(angy-10)%360;
glutPostRedisplay();
break;
case 'z':
angz=(angz+10)%360;
glutPostRedisplay();
break;
case 'Z':
angz=(angz-10)%360;
glutPostRedisplay();
break;
case 'r':
case 'R':
angx=0;
angy=0;
angz=0;
x=y=z=0.0;
glutPostRedisplay();
break;
case 27:
exit(0);
break;
default:
break;
}}
void ortho(void){
if (winWidth <= winHeight)
glOrtho(-10.0,10.0,-10.0*(GLfloat)winHeight/(GLfloat)winWidth,10.0*(GLfloat)winHeight/(GLfloat)winWidth,-10.0,10.0);
else glOrtho(-10.0*(GLfloat)winWidth/(GLfloat)winHeight,10.0*(GLfloat)winWidth/(GLfloat)winHeight,-10.0,10.0,-10.0,10.0);
}
void reshape (int w, int h){
glViewport(0, 0, w, h);
winWidth = w;
winHeight = h;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
ortho();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void idle(void){
glutSetWindow(window);
glutPostRedisplay();
}
void visible(int vis){
if (vis == GLUT_VISIBLE)
glutIdleFunc(idle);
else
glutIdleFunc(NULL);
}
void mouse(int button, int state, int x, int y){
if(button == GLUT_LEFT_BUTTON)
{
}}
int main(int argc,char** argv){
GLubyte image[64][64][3];
int i, j, c;
for(i=0;i<64;i++){
for(j=0;j<64;j++){
c = (((((i&0x8)==0)^((j&0x8)))==0))*255;
image[i][j][0]= (GLubyte) c;
image[i][j][1]= (GLubyte) c;
image[i][j][2]= (GLubyte) c;
}}
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(500,500);
glutInitWindowPosition(400,100);
window = glutCreateWindow("Práctica 9 Ejercicio 3");
init();
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutVisibilityFunc(visible);
glEnable(GL_DEPTH_TEST);
glTexImage2D(GL_TEXTURE_2D,0,3,64,64,0,GL_RGB,GL_UNSIGNED_BYTE, image);
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
glutMainLoop();
return 0;
}