1:#include <GL/glut.h>
2:#include <math.h>
3:#include "modelado.h"
4:
5:/*--------------------------------------------------------------------------
6: Devuelve el valor de x del punto que gira.
7: R: el radio de giro.
8: N: el n√∫mero total de tramos en el anillo.
9: n: el tramo actual.
10: --------------------------------------------------------------------------*/
11:float dameX(float R, int N, int n) {
12: float x = (float)R*cos(n*(2*M_PI)/N);
13: return x;
14:}
15:
16:/*--------------------------------------------------------------------------
17: Devuelve el valor de z del punto que gira.
18: R: el radio de giro.
19: N: el n√∫mero total de tramos en el anillo.
20: n: el tramo actual.
21: --------------------------------------------------------------------------*/
22:float dameZ(float R, int N, int n) {
23: float z = (float)R*sin(n*(2*M_PI)/N);
24: return z;
25:}
26:
27:/*--------------------------------------------------------------------------
28: Dibuja un anillo.
29: R: el radio del anillo.
30: y: la altura a la que se dibuja el anillo.
31: N: el n√∫mero de tramos del anillo.
32: --------------------------------------------------------------------------*/
33:void anillo(float R, float y, int N) {
34: int i;
35: float x, z;
36:
37: glBegin(GL_LINE_LOOP);
38:
39: for(i = 0; i < N; i++) {
40: x = dameX(R, N, i);
41: z = dameZ(R, N, i);
42: glVertex3f(x, y, z);
43: }
44: glEnd();
45:}
46:
47:// dibujo de las tapas en conos y cilindros
48:void tapa(float R, float y, int N) {
49: int i;
50: float x, z;
51: Vector3D n;
52:
53: glBegin(GL_POLYGON);
54:
55: for(i = 0; i < N; i++) {
56: x = dameX(R, N, i);
57: z = dameZ(R, N, i);
58: n = normal(R, 1, y, 1, N, i);
59: glTexCoord2f(x, z);
60: glNormal3f(n.a, n.b, n.c);
61: glVertex3f(x, y, z);
62: }
63: glEnd();
64:}
65:
66:/*--------------------------------------------------------------------------
67: Dibuja una tira de cuadril·teros.
68: R1, R2, R3: radios de trea anillos consecutivos.
69: y1, y2, y3: altura de cada uno de los anillos.
70: N: n˙mero de pasos sobre cada anillo.
71: --------------------------------------------------------------------------*/
72:// utilitzo cinta com a tira
73:void tira(float R, float dR, float y, float dy, float N) {
74: int i;
75: float x, z;
76: Vector3D n;
77:
78: glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
79: glBegin(GL_TRIANGLE_STRIP);
80: for(i = 0; i <= N; i++) {
81: x = dameX(R, N, i);
82: z = dameZ(R, N, i);
83: n = normal(R, dR, y, dy, N, i);
84: glTexCoord2f((float)i/N, y+0.5f);
85: glNormal3f(n.a, n.b, n.c);
86:
87: //asignacion de coordenadas de textura
88: glVertex3f(x, y, z);
89: glTexCoord2f((float)i/N, y+dy+0.5f);
90: x = dameX(R+dR, N, i);
91: z = dameZ(R+dR, N, i);
92: n = normal(R+dR, dR, y, dy, N, i);
93: glNormal3f(n.a, n.b, n.c);
94: glVertex3f(x, y+dy, z);
95: }
96: glEnd();
97:}
98:
99:/*--------------------------------------------------------------------------
100: Devuelve la normal de un vÈrtice sobre una superficie de revoluciÛn.
101: R1: radio del primer anillo.
102: R2: radio del segundo anillo.
103: y1: altura del primer anillo.
104: y2: altura del segundo anillo.
105: N: el n˙mero total de tramos en el anillo.
106: n: el tramo actual.
107: --------------------------------------------------------------------------*/
108:Vector3D normal(float R, float dR, float y, float dy, int N, int n) {
109: Punto3D p, q, r;
110: Vector3D v, w, normal;
111:
112: p.x = dameX(R, N, n);
113: p.y = y;
114: p.z = dameZ(R, N, n);
115: if(R == 0.0f) {
116: q.x = dameX(R+dR, N, (n+1)%N);
117: q.y = y+dy;
118: q.z = dameZ(R+dR, N, (n+1)%N);
119: }
120: else {
121: q.x = dameX(R, N, (n+1)%N);
122: q.y = y;
123: q.z = dameZ(R, N, (n+1)%N);
124: }
125: r.x = dameX(R+dR, N, n);
126: r.y = y+dy;
127: r.z = dameZ(R+dR, N, n);
128: v = vector(p, q);
129: w = vector(p, r);
130: normal = productoVectorial(w, v);
131:
132: return (normal);
133:}
134:
135:
136:/*--------------------------------------------------------------------------
137: Devuelve un valor de radio en función de la altura
138: que se le pasa como par√°metro para dibujar un cono.
139: y: el valor de la altura.
140: --------------------------------------------------------------------------*/
141:float fCono(float y) {
142: return ((y+0.5f)/2);
143:}
144:
145:/*--------------------------------------------------------------------------
146: Dibuja un cono.
147: N: el n√∫mero de anillos y tramos en cada anillo
148: --------------------------------------------------------------------------*/
149:void conoAlambre(int N) {
150: formaAlambre(1.0f, N, fCono);
151:}
152:
153:// cono sÛlido
154:void conoSolido(int N) {
155: formaSolida(1.0f, N, fCono);
156: tapa(fCono(0.5), 0.5, N);
157:}
158:
159:
160:/*--------------------------------------------------------------------------
161: Devuelve un valor de radio en función de la altura
162: que se le pasa como par√°metro para dibujar un cilindro.
163: y: el valor de la altura.
164: --------------------------------------------------------------------------*/
165:float fCilindro(float y) {
166: return(0.5);
167:}
168:
169:
170:/*--------------------------------------------------------------------------
171: Dibuja un cilindro.
172: N: el n√∫mero de anillos y tramos en cada anillo
173: --------------------------------------------------------------------------*/
174:void cilindroAlambre(int N) {
175: formaAlambre(1.0f, N, fCilindro);
176:}
177:
178://cilindro sÛlido
179:void cilindroSolido(int N) {
180: formaSolida(1.0f, N, fCilindro);
181:
182: //tapa superior
183: tapa(fCilindro(0.5), 0.5, N);
184: //tapa inferior
185: tapa(fCilindro(0.5), -0.5, N);
186:}
187:
188:/*--------------------------------------------------------------------------
189: Devuelve un valor de radio en función de la altura
190: que se le pasa como par√°metro para dibujar un cilindro.
191: y: el valor de la altura.
192: --------------------------------------------------------------------------*/
193:float fEsfera(float y) {
194: return((float)sqrt(fabs(0.25-(y*y))));
195:}
196:
197:
198:/*--------------------------------------------------------------------------
199: Dibuja un cilindro.
200: N: el n√∫mero de anillos y tramos en cada anillo
201: --------------------------------------------------------------------------*/
202:void esferaAlambre(int N) {
203: formaAlambre(1.0f, N, fEsfera);
204:}
205:
206:// esfera sÛlida
207:void esferaSolida(int N) {
208: formaSolida(1.0f, N, fEsfera);
209:}
210:
211:// semiesfera sÛlida
212:void semiesferaSolida(int N) {
213: int i;
214: float y, r1, r2, H=1.0;
215:
216: for(i = 0; i < N/2; i++) {
217: y = i*H/N-(H/2);
218: r1 = fEsfera(y);
219: r2 = fEsfera(y+H/N);
220: tira(r1, r2-r1, y, H/N, N);
221: //tira(r1, r2-r1, y, H/N, N);
222: }
223:}
224:
225:// dibujo de un cubo
226:void cubo()
227:{
228: glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0);
229: glBegin(GL_POLYGON); /* Cara delantera */
230: glNormal3f( 0.0, 0.0, 1.0);
231: glTexCoord2f(0.0, 0.0);glVertex3f(-0.5f, 0.5f, 0.5f);
232: glTexCoord2f(0.0, 1.0);glVertex3f(-0.5f, -0.5f, 0.5f);
233: glTexCoord2f(1.0, 1.0);glVertex3f(0.5f, -0.5f, 0.5f);
234: glTexCoord2f(1.0, 0.0);glVertex3f(0.5f, 0.5f, 0.5f);
235: glEnd();
236:
237: glBegin(GL_POLYGON); /* Cara trasera */
238: glNormal3f( 0.0, 0.0, -1.0);
239: glTexCoord2f(0.0, 0.0);glVertex3f(-0.5f, 0.5f, -0.5f);
240: glTexCoord2f(0.0, 1.0);glVertex3f(0.5f, 0.5f, -0.5f);
241: glTexCoord2f(1.0, 1.0);glVertex3f(0.5f, -0.5f, -0.5f);
242: glTexCoord2f(1.0, 0.0);glVertex3f(-0.5f, -0.5f, -0.5f);
243: glEnd();
244:
245: glBegin(GL_POLYGON);
246: glNormal3f( 1.0, 0.0, 0.0);
247: glTexCoord2f(0.0, 0.0 );glVertex3f(0.5f, 0.5f, 0.5f);
248: glTexCoord2f(0.0, 1.0);glVertex3f(0.5f, -0.5f, 0.5f);
249: glTexCoord2f(1.0, 1.0);glVertex3f(0.5f, -0.5f, -0.5f);
250: glTexCoord2f(1.0, 0.0);glVertex3f(0.5f, 0.5f, -0.5f);
251: glEnd();
252:
253: glBegin(GL_POLYGON);
254: glNormal3f( -1.0, 0.0, 0.0);
255: glTexCoord2f(0.0, 0.0);glVertex3f(-0.5f, 0.5f, -0.5f);
256: glTexCoord2f(0.0, 1.0);glVertex3f(-0.5f, -0.5f, -0.5f);
257: glTexCoord2f(1.0, 1.0);glVertex3f(-0.5f, -0.5f, 0.5f);
258: glTexCoord2f(1.0, 0.0);glVertex3f(-0.5f, 0.5f, 0.5f);
259: glEnd();
260:
261: glBegin(GL_POLYGON);
262: glNormal3f( 0.0, 1.0, 0.0);
263: glTexCoord2f(0.0, 0.0);glVertex3f(-0.5f, 0.5f, -0.5f);
264: glTexCoord2f(0.0, 1.0);glVertex3f(-0.5f, 0.5f, 0.5f);
265: glTexCoord2f(1.0, 1.0);glVertex3f(0.5f, 0.5f, 0.5f);
266: glTexCoord2f(1.0, 0.0);glVertex3f(0.5f, 0.5f, -0.5f);
267: glEnd();
268:
269: glBegin(GL_POLYGON);
270: glNormal3f( 0.0, -1.0, 0.0);
271: glTexCoord2f(0.0, 0.0);glVertex3f(0.5f, -0.5f, -0.5f);
272: glTexCoord2f(0.0, 1.0);glVertex3f(0.5f, -0.5f, 0.5f);
273: glTexCoord2f(1.0, 1.0);glVertex3f(-0.5f, -0.5f, 0.5f);
274: glTexCoord2f(1.0, 0.0);glVertex3f(-0.5f, -0.5f, -0.5f);
275: glEnd();
276:}
277:
278:
279:/*--------------------------------------------------------------------------
280: Algoritmo de dibujo para una figura de revolución.
281: H: la altura de la figura.
282: N: el n√∫mero de anillos y divisiones en cada anillo.
283: f(float y): puntero a la función que nos devuelve.
284: el valor de radio en función de y.
285: --------------------------------------------------------------------------*/
286:void formaAlambre(float H, int N, float(*f)(float y)) {
287: int i;
288: float y, r;
289:
290: for(i = 0; i < N; i++) { // Para cada nivel de altura
291: y = i*H/(N-1)-(H/2);
292: r = f(y); // obtenemos el radio
293: anillo(r, y, N); // y dibujamos un anillo
294: }
295:}
296:
297:/*--------------------------------------------------------------------------
298: Algoritmo de dibujo para una forma sÛlida de revoluciÛn.
299: H: la altura de la figura.
300: N: el n˙mero de anillos y divisiones en cada anillo.
301: f(float y): puntero a la funciÛn que nos devuelve.
302: el valor de radio en funciÛn de y.
303:--------------------------------------------------------------------------*/
304:void formaSolida(float H, int N, float(*f)(float y)) {
305: int i;
306: float y, r1, r2;
307:
308: for(i = 0; i < N; i++) {
309: y = i*H/N-(H/2);
310: r1 = f(y);
311: r2 = f(y+(H/N));
312: tira(r1, r2-r1, y, H/N, N);
313: //tira(r1, r2-r1, y, H/N, N);
314: }
315:}
316:
317:
318://***********************************************************************
319:// proyecto, el parque...
320:
321:// dibujo de una columna del templete -> cilindro
322:void columna(){
323: //friso inferior cubo
324: glPushMatrix();
325: glTranslatef(0.0f, -0.48f, 0.0f);
326: glScalef(0.25f, 0.05f, 0.25f);
327: cubo(20);
328: glPopMatrix();
329: //friso inferior cilindro
330: glPushMatrix();
331: glTranslatef(0.0f, -0.44f, 0.0f);
332: glScalef(0.24f, 0.05f, 0.24f);
333: cilindroSolido(20);
334: glPopMatrix();
335: //friso superior cubo
336: glPushMatrix();
337: glTranslatef(0.0f, 0.48f, 0.0f);
338: glScalef(0.25f, 0.05f, 0.25f);
339: cubo(20);
340: glPopMatrix();
341: //friso superior cilindro
342: glPushMatrix();
343: glTranslatef(0.0f, 0.44f, 0.0f);
344: glScalef(0.24f, 0.05f, 0.24f);
345: cilindroSolido(20);
346: glPopMatrix();
347: //cilindro
348: glPushMatrix();
349: glScalef(0.2f, 1.0f, 0.2f);
350: cilindroSolido(20);
351: glPopMatrix();
352:}
353:
354:// base -> dos cilindros achatados
355:void base(){
356: int esq=20;
357: //superior
358: glPushMatrix();
359: glTranslatef(0.0f, 0.09f, 0.0f);
360: glScalef(1.65f, 0.09f, 1.65f);
361: cilindroSolido(esq);
362: glPopMatrix();
363: //inferior
364: glPushMatrix();
365: glScalef(1.8f, 0.09f, 1.8f);
366: cilindroSolido(esq);
367: glPopMatrix();
368:}
369:
370:// c˙pula -> cono + cilindro achatados
371:void cupula(){
372: int esq=20;
373:
374: // cilindro inferior
375: glPushMatrix();
376: glTranslatef(0.0f, -0.39f, 0.0f);
377: glScalef(1.6f, 0.05f, 1.6f);
378: cilindroSolido(esq);
379: glPopMatrix();
380:
381: // cilindro medio
382: glPushMatrix();
383: glTranslatef(0.0f, -0.34f, 0.0f);
384: glScalef(1.65f, 0.05f, 1.65f);
385: cilindroSolido(esq);
386: glPopMatrix();
387:
388: // cilindro superior
389: glPushMatrix();
390: glTranslatef(0.0f, -0.29f, 0.0f);
391: glScalef(1.7f, 0.05f, 1.7f);
392: cilindroSolido(esq);
393: glPopMatrix();
394:
395: // cono achatado
396: glPushMatrix();
397: glTranslatef(0.0f, -0.04f, 0.0f);
398: glRotatef(180.0f, 1.0f, 0.0f, 0.0f);
399: glScalef(1.8f, 0.45f, 1.8f);
400: conoSolido(20);
401: glPopMatrix();
402:}
403:
404://el templete completo
405:void templete(){
406: float sx, cx;
407: float rad=0.67;
408: float ancho=0.65;
409:
410: sx = rad*sin(M_PI/4);
411: cx = rad*cos(M_PI/4);
412:
413: //base
414: glBindTexture(GL_TEXTURE_2D, nombreTexturas[4]);
415: glPushMatrix();
416: glTranslatef(0.0f, -0.6f, 0.0f);
417: base();
418: glPopMatrix();
419:
420: //cilindro vertical 1
421: glPushMatrix();
422: glTranslatef(rad, 0.04f, 0.0f);
423: glScalef(ancho, 1.0f, ancho);
424: columna();
425: glPopMatrix();
426:
427: //cilindro vertical 2
428: glPushMatrix();
429: glTranslatef(-rad, 0.04f, 0.0f);
430: glScalef(ancho, 1.0f, ancho);
431: columna();
432: glPopMatrix();
433:
434: //cilindro vertical 3
435: glPushMatrix();
436: glTranslatef(cx, 0.04f, sx);
437: glRotatef(-45.0f, 0.0f, 1.0f, 0.0f);
438: glScalef(ancho, 1.0f, ancho);
439: columna();
440: glPopMatrix();
441:
442: //cilindro vertical 4
443: glPushMatrix();
444: glTranslatef(-cx, 0.04f, sx);
445: glRotatef(45.0f, 0.0f, 1.0f, 0.0f);
446: glScalef(ancho, 1.0f, ancho);
447: columna();
448: glPopMatrix();
449:
450: //cilindro vertical 5
451: glPushMatrix();
452: glTranslatef(cx, 0.04f, -sx);
453: glRotatef(45.0f, 0.0f, 1.0f, 0.0f);
454: glScalef(ancho, 1.0f, ancho);
455: columna();
456: glPopMatrix();
457:
458: //cilindro vertical 6
459: glPushMatrix();
460: glTranslatef(-cx, 0.04f, -sx);
461: glRotatef(-45.0f, 0.0f, 1.0f, 0.0f);
462: glScalef(ancho, 1.0f, ancho);
463: columna();
464: glPopMatrix();
465:
466: //cilindro vertical 7
467: glPushMatrix();
468: glTranslatef(0.0f, 0.04f, rad);
469: glRotatef(0.0f, 0.0f, 1.0f, 0.0f);
470: glScalef(ancho, 1.0f, ancho);
471: columna();
472: glPopMatrix();
473: //cilindro vertical 8
474: glPushMatrix();
475: glTranslatef(0.0f, 0.04f, -rad);
476: glRotatef(0.0f, 0.0f, 1.0f, 0.0f);
477: glScalef(ancho, 1.0f, ancho);
478: columna();
479: glPopMatrix();
480:
481: //c˙pula
482: glPushMatrix();
483: glTranslatef(0.0f, 0.95f, 0.0f);
484: cupula();
485: glPopMatrix();
486:}
487:
488:// dibujo de una farola
489:void farola(){
490: glDisable(GL_TEXTURE_2D);
491: // palo largo
492: glPushMatrix();
493: glTranslatef(0.0f, 0.5f, 0.0f);
494: glScalef(0.12f, 1.5f, 0.12f);
495: negro();
496: cilindroSolido(20);
497: glPopMatrix();
498: // palo corto
499: glPushMatrix();
500: glTranslatef(0.0f, 0.0f, 0.0f);
501: glScalef(0.17f, 0.5f, 0.17f);
502: negro();
503: cilindroSolido(20);
504: glPopMatrix();
505: // esfera
506: glPushMatrix();
507: glTranslatef(0.0f, 1.3f, 0.0f);
508: glScalef(0.34f, 0.34f, 0.34f);
509: amarillo();
510: esferaSolida(20);
511: glPopMatrix();
512: glEnable(GL_TEXTURE_2D);
513:}
514:
515:// dibujo de un banco (dos tablones + cuatro patas)
516:void tablon(){
517: glPushMatrix();
518: glScalef(1.7f, 0.1f, 0.6f);
519: cubo();
520: glPopMatrix();
521:}
522:void pata(){
523: glPushMatrix();
524: glScalef(0.2f, 0.4f, 0.2f);
525: cilindroSolido(20);
526: glPopMatrix();
527:}
528:void banco(){
529: negro();
530: glDisable(GL_TEXTURE_2D);
531: //pata1
532: glPushMatrix();
533: glTranslatef(0.55f, -0.23f, 0.15f);
534: glScalef(0.8f, 0.9f, 0.8f);
535: pata();
536: glPopMatrix();
537: //pata2
538: glPushMatrix();
539: glTranslatef(-0.55f, -0.23f, 0.15f);
540: glScalef(0.8f, 0.9f, 0.8f);
541: pata();
542: glPopMatrix();
543: //pata3
544: glPushMatrix();
545: glTranslatef(0.55f, -0.23f, -0.15f);
546: glScalef(0.8f, 0.9f, 0.8f);
547: pata();
548: glPopMatrix();
549: //pata4
550: glPushMatrix();
551: glTranslatef(-0.55f, -0.23f, -0.15f);
552: glScalef(0.8f, 0.9f, 0.8f);
553: pata();
554: glPopMatrix();
555: glEnable(GL_TEXTURE_2D);
556:
557: //respaldo
558: cobre();
559: glBindTexture(GL_TEXTURE_2D, nombreTexturas[3]);
560: glPushMatrix();
561: glTranslatef(0.0f, 0.28f, -0.28f);
562: glScalef(1.0f, 0.8f, 1.0f);
563: glRotatef(80.0f, 1.0f, 0.0f, 0.0f);
564: tablon();
565: glPopMatrix();
566: //tabla base
567: glPushMatrix();
568: tablon();
569: glPopMatrix();
570:}
571:
572:
573:
574:// dibujo de un ·rbol
575:void arbol(){
576: // tronco
577: glPushMatrix();
578: glTranslatef(0.0f, -0.35f, 0.0f);
579: glScalef(0.08f, 0.7f, 0.08f);
580: azul();
581: glBindTexture(GL_TEXTURE_2D, nombreTexturas[3]);
582: cilindroSolido(30);
583: glPopMatrix();
584:
585: glDisable(GL_TEXTURE_2D);
586: // copa
587: glPushMatrix();
588: glTranslatef(0.0f, -0.1f, 0.0f);
589: glRotatef(180.0f, 1.0f, 0.0f, 0.0f);
590: glScalef(0.35f, 0.8f, 0.35f);
591: verde();
592: conoSolido(20);
593: glPopMatrix();
594: glEnable(GL_TEXTURE_2D);
595:}
596:
597:// dibujo del suelo -> semiesfera gigante achatada
598:void suelo(void)
599:{
600: // suelo
601: glPushMatrix();
602: blanco();
603: glTranslatef(0.0, -0.63, 0.0);
604: glScalef( 30.0 ,0.1 ,30.0 );
605: glRotatef(180.0 ,0 , 1, 0 );
606: glBindTexture(GL_TEXTURE_2D, nombreTexturas[0]);
607: semiesferaSolida(20);
608: glPopMatrix();
609: // relleno mar
610: glPushMatrix();
611: glTranslatef(0.0, -0.8, 0.0);
612: glScalef( 125.0 ,0.001 ,125.0 );
613: glBindTexture(GL_TEXTURE_2D, nombreTexturas[2]);
614: semiesferaSolida(20);
615: glPopMatrix();
616:}
617:
618:// semicÌrculo de farolas
619:void semiFarola(float radFM, float yTransFarola, float wFarola, float hFarola){
620:
621: float i, angle=(M_PI/6), max=(M_PI);
622:
623: i=angle;
624:
625:// while (i<(max-angle)) { // <- codi windows
626: while (i<(max-(angle/2))) { // <- codi unix
627: glPushMatrix();
628: glTranslatef(radFM*sin(i), yTransFarola, radFM*cos(i));
629: glScalef(wFarola, hFarola, wFarola);
630: farola();
631: glPopMatrix();
632: i+=angle;
633: }
634:}
635:
636:// semicÌrculo de bancos
637:void semiBanco(float radFM){
638:
639: float i, angle=(M_PI/6), max=(M_PI);
640:
641: i=angle;
642:// while (i<(max-angle)) { // per a windows
643: while (i<(max-(angle/2))) { // per a unix
644: glPushMatrix();
645: glTranslatef((-radFM*sin(i)), -0.46, (-radFM*cos(i)));
646: glScalef(0.5f, 0.5f, 0.5f);
647: glRotatef((i*180/M_PI), 0.0f, 1.0f, 0.0f);
648: banco();
649: glPopMatrix();
650: i+=angle;
651: }
652:}
653:
654:
655:// cÌrculo de ·rboles. Aleatorizamos el tamaÒo de cada ·rbol (3 tamaÒos disponibles)
656:void semiArbol(float radio, float angle){
657:
658: float i, max=(M_PI*2);
659: float rd, tr;
660:
661: i=angle*2;
662: while (i<(max-angle-0.1)) {
663: rd= (rand()%3);
664: tr = 0.7;
665: if (rd==0) {
666: //·rboles tamaÒo 1
667: glPushMatrix();
668: glTranslatef(radio*sin(i)+tr, 1.4f, radio*cos(i));
669: glScalef(3.0f, 3.0f, 3.0f);
670: arbol();
671: glPopMatrix();
672: } else
673: if (rd==1){
674: //·rboles tamaÒo 2
675: glPushMatrix();
676: glTranslatef(radio*sin(i)-tr, 0.95f, radio*cos(i));
677: glScalef(2.0f, 2.3f, 2.0f);
678: arbol();
679: glPopMatrix();
680: } else {
681: //·rboles tamaÒo 3
682: glPushMatrix();
683: glTranslatef(radio*sin(i), 1.14f, radio*cos(i)-tr);
684: glScalef(2.5f, 2.6f, 2.5f);
685: arbol();
686: glPopMatrix();
687: }
688: i+=angle;
689: }
690:}
691:
692:// cÌrculo de flores(radio_maximo, angulo)
693:void flor(float radio, float angle){
694:
695: float i, j, max=(M_PI*2), rd2, rflor, prad, ang=angle;
696:
697: rflor=radio/3.2;
698:
699: glDisable(GL_TEXTURE_2D);
700:
701: //n˙mero de filas
702: prad=radio/4;
703: j=prad;
704: while (j<=radio) {
705: i=0;
706: while (i<=(max)) {
707: glPushMatrix();
708: glTranslatef(j*sin(i), 0.0f, j*cos(i));
709: glScalef(rflor, rflor, rflor);
710: glRotatef(180.0, 1.0f, 0.0f, 0.0f);
711: //aleatoritzaciÛn de los colores
712: rd2=(rand()%4);
713: if (rd2==0) rojo2();
714: else {
715: if (rd2==1) verde();
716: else {
717: if (rd2==2) azul();
718: else amarillo();
719: }
720: }
721: semiesferaSolida(10);
722: glPopMatrix();
723: i+=ang;
724: }
725: ang=ang-0.2;
726: j+=prad;
727:
728: //modificar ·ngulo...
729: angle=angle+0.01;
730: }
731: glPushMatrix();
732: glScalef(rflor, rflor, rflor);
733: glRotatef(180.0, 1.0f, 0.0f, 0.0f);
734: //aleatoritzaciÛn de los colores
735: amarillo();
736: semiesferaSolida(20);
737: glPopMatrix();
738: glEnable(GL_TEXTURE_2D);
739:}
740:
741:
742:
743:// cÌrculo de flores
744:void circuloFlores(){
745:
746: float i, angle=(M_PI/4), max=(M_PI*2), dist=1.8;
747:
748: i=0;
749: while (i<(max)) {
750: glPushMatrix();
751: glTranslatef((sin(i))/dist, -0.65, (cos(i))/dist);
752: glScalef(0.5f, 0.5f, 0.5f);
753: flor(0.5, 0.8);
754: glPopMatrix();
755: i+=angle;
756: }
757: glPushMatrix();
758: glTranslatef(0.0, -0.63, 0.0);
759: glScalef(0.5f, 0.5f, 0.5f);
760: flor(0.5, 0.8);
761: glPopMatrix();
762:}
763:
764://dibujo de todas las flores
765:void flores(float radFM)
766:{
767: float i;
768:
769: // pasillo de flores
770: for (i=(radFM); i<=14; i+=2) {
771: glPushMatrix();
772: glTranslatef(-radFM+(-0.07*i)+1, -0.63, i-0.3);
773: glScalef(0.5f, 0.5f, 0.5f);
774: //glRotatef(90.0f, 0.0f, 1.0f, 0.0f);
775: flor(0.5, 0.8);
776: glPopMatrix();
777:
778: glPushMatrix();
779: glTranslatef(radFM-(-0.07*i)-1, -0.63, i-0.3);
780: glScalef(0.5f, 0.5f, 0.5f);
781: //glRotatef(270.0f, 0.0f, 1.0f, 0.0f);
782: //aluminio();
783: flor(0.5, 0.8);
784: glPopMatrix();
785: }
786:
787: //circulo central de flores
788: circuloFlores();
789:}
790:
791:/*--------------------------------------------------------------------------
792: Aquí es donde se debe crear toda la escena.
793: --------------------------------------------------------------------------*/
794:void escena(void)
795:{
796: float wFarola=1.2, hFarola=1.2, yTransFarola=-0.4, radFM=2.9, radFMM=3.1;
797: int i;
798:
799: //suelo
800: glPushMatrix();
801: suelo();
802: glPopMatrix();
803:
804: //cielo
805: glPushMatrix();
806: glTranslatef(0.0,-5, 0.0);
807: glScalef( 120.0 ,120.0 ,120.0 );
808: glRotatef(180.0, 1.0f, 0.0f, 0.0f);
809: blanco();
810: glBindTexture(GL_TEXTURE_2D, nombreTexturas[1]);
811: semiesferaSolida(20);
812: glPopMatrix();
813:
814: //templete
815: glPushMatrix();
816: glTranslatef(0.0f, 0.3f, -3.0f);
817: glScalef(1.7f, 1.5f, 1.7f);
818: templete();
819: glPopMatrix();
820:
821: //farola 1 semicÌrculo
822: glPushMatrix();
823: glTranslatef(0.0f, 0.0f, -radFM);
824: glScalef(1.0, 1.0, 1.0);
825: glRotatef(90.0f, 0.0f, 1.0f, 0.0f);
826: semiFarola(radFM, yTransFarola, wFarola, hFarola);
827: glPopMatrix();
828:
829: //farola 2 semicÌrculo
830: glPushMatrix();
831: glTranslatef(-radFM, 0.0f, 0.0f);
832: glScalef(1.0, 1.0, 1.0);
833: glRotatef(180.0f, 0.0f, 1.0f, 0.0f);
834: semiFarola(radFM, yTransFarola, wFarola, hFarola);
835: glPopMatrix();
836:
837: //farola 3 semicÌrculo
838: glPushMatrix();
839: glTranslatef(radFM, 0.0f, 0.0f);
840: glScalef(1.0, 1.0, 1.0);
841: semiFarola(radFM, yTransFarola, wFarola, hFarola);
842: glPopMatrix();
843:
844: //farola 1 -> izquierda
845: glPushMatrix();
846: glTranslatef(radFMM, yTransFarola, -radFMM);
847: glScalef(wFarola, hFarola, wFarola);
848: farola();
849: glPopMatrix();
850: //farola 2 -> derecha
851: glPushMatrix();
852: glTranslatef(-radFMM, yTransFarola, -radFMM);
853: glScalef(wFarola, hFarola, wFarola);
854: farola();
855: glPopMatrix();
856:
857: // pasillo de farolas
858: for (i=(radFM+1); i<=12; i++) {
859: glPushMatrix();
860: glTranslatef(-radFM+(-0.07*i), yTransFarola, i);
861: glScalef(wFarola, hFarola, wFarola);
862: farola();
863: glPopMatrix();
864:
865: glPushMatrix();
866: glTranslatef(radFM+(0.07*i), yTransFarola, i);
867: glScalef(wFarola, hFarola, wFarola);
868: farola();
869: glPopMatrix();
870: }
871:
872: // pasillo de bancos
873: for (i=(radFM+1); i<=12; i+=2) {
874: glPushMatrix();
875: glTranslatef(-radFM+(-0.07*i)+1, -0.46, i+0.7);
876: glScalef(0.5f, 0.5f, 0.5f);
877: glRotatef(90.0f, 0.0f, 1.0f, 0.0f);
878: banco();
879: glPopMatrix();
880:
881: glPushMatrix();
882: glTranslatef(radFM-(-0.07*i)-1, -0.46, i+0.7);
883: glScalef(0.5f, 0.5f, 0.5f);
884: glRotatef(270.0f, 0.0f, 1.0f, 0.0f);
885: banco();
886: glPopMatrix();
887: }
888:
889: // arco bancos 1
890: glPushMatrix();
891: glTranslatef(-radFM+1, 0.0f, 0.0f);
892: semiBanco(radFM-0.2);
893: glPopMatrix();
894: // arco bancos 2
895: glPushMatrix();
896: glTranslatef(radFM-1, 0.0f, 0.0f);
897: glRotatef(180.0f, 0.0f, 1.0f, 0.0f);
898: semiBanco(radFM-0.2);
899: glPopMatrix();
900:
901: // arboles
902: semiArbol(13.5, (M_PI/13));
903: semiArbol(11, (M_PI/12));
904: semiArbol(9, (M_PI/9));
905: semiArbol(7, (M_PI/7));
906:
907: // la inclusiÛn de las flores es optativa porque provoca un alto coste
908: // (comentar la siguiente lÌnea para quitarlas)
909: flores(radFM);
910:}
911:
912:
913:void iniciaDisplayLists(void)
914:{
915: escenario = glGenLists (1);
916:
917: if (escenario != 0)
918: {
919: glNewList (escenario, GL_COMPILE);
920: escena();
921: glEndList ();
922: }
923:}