DOCUMENTACIÓN AQUYNZA DEL DESARROLLADOR

00001 //===========================================================================
00002 //= fondo.h                                           Desde octubre de 1998 =
00003 //=-------------------------------------------------------------------------=
00004 //= Definiciones de la clase FONDO.                                         =
00005 //=-------------------------------------------------------------------------=
00006 //= ADVERTENCIA: ESTE SOFTWARE NO ESTA CONCEBIDO NI DISENNADO PARA EL USO   =
00007 //= EN EQUIPO DE CONTROL EN LINEA EN ENTORNOS PELIGROSOS QUE REQUIERAN UN   =
00008 //= DESEMPENNO LIBRE DE FALLAS, COMO LA OPERACION DE PLANTAS NUCLEARES,     = 
00009 //= SISTEMAS DE NAVEGACION O COMUNICACION EN AVIONES, TRAFICO AEREO,        =
00010 //= EQUIPO MEDICO DEL CUAL DEPENDAN VIDAS HUMANAS O SISTEMAS DE ARMAMENTO,  =
00011 //= EN LOS CUALES UNA FALLA EN EL SOFTWARE PUEDA IMPLICAR DIRECTAMENTE LA   =
00012 //= MUERTE, DANNOS PERSONALES O DANNOS FISICOS Y/O AMBIENTALES GRAVES       =
00013 //= ("ACTIVIDADES DE ALGO RIESGO").                                         =
00014 //=-------------------------------------------------------------------------=
00015 //= Autor original: Oscar J. Chavarro G.  A.K.A. JEDILINK. Copyright (c),   =
00016 //= 1997 - 2003, oscarchavarro@hotmail.com                                  =
00017 //= AQUYNZA es software libre, y se rige bajo los terminos de la licencia   =
00018 //= LGPL de GNU (http://www.gnu.org). Para mayor informacion respecto a la  =
00019 //= licencia de uso, consulte el archivo ./doc/LICENCIA en la distribucion. =
00020 //===========================================================================
00021 
00022 #include "jed_defs.h"
00023 
00024 #if PLATAFORMA == i386_LINUX_GCC || PLATAFORMA == SPARC64_LINUX_GCC
00025   // OJO: Esto deberia usarse en las demas plataformas?
00026   // OJO: BSD Parece no estar funcionando!
00027   #ifndef __USE_BSD
00028     #define __USE_BSD
00029   #endif
00030   #ifndef __USE_SVID
00031     #define __USE_SVID
00032   #endif
00033   #ifndef __USE_POSIX
00034     #define __USE_POSIX
00035   #endif
00036   #ifndef __USE_MISC
00037     #define __USE_MISC
00038   #endif
00039 #endif
00040 
00041 #include <stdio.h>
00042 #include <stdlib.h>
00043 #include <string.h>
00044 
00045 #include "toolkits/entorno/fondo.h"
00046 #include "jed_gl.h"
00047 
00048 //===========================================================================
00049 //= Macros generales para todas las clases FONDO                            =
00050 //===========================================================================
00051 
00052 // OJO: Esta macro no funciona bien con Mesa basado en Glide
00053 #define PONER_FONDO_COLOR(c)                                             \
00054     glMatrixMode(GL_PROJECTION);    glPushMatrix();    glLoadIdentity(); \
00055     glMatrixMode(GL_TEXTURE);       glPushMatrix();    glLoadIdentity(); \
00056     glMatrixMode(GL_MODELVIEW);     glPushMatrix();    glLoadIdentity(); \
00057     glClear(GL_DEPTH_BUFFER_BIT);                                        \
00058     glShadeModel(GL_FLAT);          glDisable(GL_BLEND);                 \
00059     glDisable(GL_LIGHTING);         glDisable(GL_DEPTH_TEST);            \
00060     glDisable(GL_TEXTURE_2D);                                            \
00061     glColor3f((c).r, (c).g, (c).b); glFrontFace(GL_CCW);                 \
00062     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);                           \
00063     glBegin(GL_QUADS);                                                   \
00064         glVertex2f(1, 1);           glVertex2f(-1, 1);                   \
00065         glVertex2f(-1, -1);         glVertex2f(1, -1);                   \
00066     glEnd();                                                             \
00067     glPopMatrix();                                                       \
00068     glMatrixMode(GL_TEXTURE);    glPopMatrix();                          \
00069     glMatrixMode(GL_PROJECTION);    glPopMatrix();                       \
00070     glMatrixMode(GL_MODELVIEW);                                          \
00071     glEnable(GL_DEPTH_TEST);                                             
00072 
00073 #ifdef NONONO
00074 #define PONER_FONDO_COLOR(c)                                             \
00075     glClearColor((c).r, (c).g, (c).b, 1);                                \
00076     glShadeModel(GL_FLAT);                                               \
00077     glClear(GL_COLOR_BUFFER_BIT);                                        \
00078     glClear(GL_DEPTH_BUFFER_BIT);                                        \
00079     glEnable(GL_DEPTH_TEST);                                             
00080 #endif
00081 
00082 #define INICIAR_LISTA() \
00083     if ( !nuevito ) glDeleteLists(lista_gl, 1); \
00084     lista_gl = glGenLists(1); \
00085     glNewList(lista_gl, GL_COMPILE);
00086 
00087 #define TERMINAR_LISTA() \
00088     glEndList(); \
00089     nuevito = FALSE;
00090 
00091 #define ESPERO(tipo, msg) \
00092     if ( tipo_token != (tipo) ) { \
00093         fprintf(stderr, "<FONDO> ERROR: Esperaba %s y recibi [%s].\n", \
00094           (msg), cad); fflush(stderr);  return FALSE; \
00095     }
00096 
00097 //===========================================================================
00098 //= CLASE FONDO                                                             =
00099 //===========================================================================
00100 
00101 FONDO::FONDO()
00102 {
00103     nuevito = TRUE;
00104 }
00105 
00106 FONDO::~FONDO() {
00107     ;
00108 }
00109 
00110 void
00111 FONDO::pintar_povray(FILE *fd)
00112 {
00113     fprintf(fd, "// WARNING: Fondo no implementado!\n");
00114 }
00115 
00116 //===========================================================================
00117 //= CLASE FONDO_SENCILLO                                                    =
00118 //===========================================================================
00119 
00120 FONDO_SENCILLO::FONDO_SENCILLO() : FONDO() {
00121     ;
00122 }
00123 
00124 FONDO_SENCILLO::~FONDO_SENCILLO() {
00125     ;
00126 }
00127 
00128 void
00129 FONDO_SENCILLO::init(void)
00132 {
00133     // El fondo sencillo... no hace nada!
00134     ;
00135 }
00136 
00137 #ifdef GL_ENABLED
00138 void
00139 FONDO_SENCILLO::pintar_gl(CAMARA * /*Camara*/)
00142 {
00143     PONER_FONDO_COLOR(_color);
00144 }
00145 #endif
00146 
00147 void
00148 FONDO_SENCILLO::pintar_povray(FILE *fd)
00149 {
00150     fprintf(fd,
00151         "background { color rgb <%f, %f, %f> }\n", _color.r, _color.g, _color.b
00152     );
00153 }
00154 
00155 BOOLEAN
00156 FONDO_SENCILLO::leer(TOKENIZADOR *Sabiondo)
00157 {
00158     char cad[1000];
00159     int tipo_token = TK_DESCONOCIDO, pos;
00160 
00161     pos = 2;
00162     while ( tipo_token != TK_CERRAR ) {
00163         tipo_token = Sabiondo->siguiente_token(cad);
00164         switch ( pos ) {
00165          /*
00166             case 1:
00167               ESPERO(TK_CADENA, "una cadena");
00168               if ( strlen(cad) > MAX_CAD-1 ) cad[MAX_CAD-1] = '\0'; 
00169               des_comille(cad);
00170               set_nombre(cad);
00171               pos++;
00172               break;*/
00173             case 2:  ESPERO(TK_ABRIR, "\"{\"");  pos++; break;
00174             default:
00175               if ( tipo_token == TK_CERRAR ) break;
00176               ESPERO(TK_IDENTIFICADOR, "un identificador (2)");
00177               if ( strstr(cad, "color") ) {
00178                   tipo_token = Sabiondo->siguiente_token(cad);
00179                   ESPERO(TK_VECTOR_INICIO, "el inicio de un COLOR");
00180                   _color.r = (float)atof(&cad[1]);
00181                   tipo_token = Sabiondo->siguiente_token(cad);
00182                   ESPERO(TK_NUMERO, "un numero (dato 2 de un COLOR)");
00183                   _color.g = (float)atof(cad);
00184                   tipo_token = Sabiondo->siguiente_token(cad);
00185                   ESPERO(TK_VECTOR_FIN, "el final de un COLOR");
00186                   cad[strlen(cad) - 1] = '\0';
00187                   _color.b = (float)atof(cad);
00188                 }
00189               ;
00190               break;
00191         }
00192     }
00193 
00194     return TRUE;
00195 }
00196 
00197 //===========================================================================
00198 //= CLASE FONDO_ESTRELLAS                                                   =
00199 //===========================================================================
00200 
00201 #define NUMSTARS 600
00202 
00203 /* X,Y,Z of each star */
00204 static GLdouble stars[NUMSTARS][3];
00205 
00206 FONDO_ESTRELLAS::FONDO_ESTRELLAS() : FONDO() {
00207     ;
00208 }
00209 
00210 FONDO_ESTRELLAS::~FONDO_ESTRELLAS() {
00211     ;
00212 }
00213 
00214 void
00215 FONDO_ESTRELLAS::init(void)
00220 {
00221     //- ALGORITMO GENERADOR DE ESTRELLAS AL AZAR ---------------------------
00222     GLdouble x,y,z,t,r;
00223     int n;
00224 
00225     SRANDOM((unsigned int)10);
00226     for ( n = 0; n < NUMSTARS; n++ ) {
00227         z = (GLdouble)n - NUMSTARS/2.0;
00228         r = sqrt( (NUMSTARS/2.0)*(NUMSTARS/2.0)-z*z );
00229         t = RANDOM() * 2 * PI;
00230         x = r * (GLdouble)cos(t);    y = r * (GLdouble)sin(t);
00231         stars[n][0] = x/200;  stars[n][1] = y/200;  stars[n][2] = z/200;
00232     }
00233 
00234 #ifdef GL_ENABLED
00235     INICIAR_LISTA();
00236     glDisable(GL_LIGHTING);   glDisable(GL_DEPTH_TEST);
00237     glDisable(GL_CULL_FACE);
00238     //glEnable(GL_POINT_SMOOTH);  glEnable(GL_BLEND);
00239     //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
00240     glDisable(GL_POINT_SMOOTH);  glDisable(GL_BLEND);
00241     glPointSize(1.1f); // OJO: No sale nada si se pone 1.0 !
00242     glColor3f(1, 1, 1); glBegin(GL_POINTS);
00243     for ( n =0; n < NUMSTARS; n += 3 ) glVertex3dv(stars[n]); glEnd();
00244     glColor3f(0.6f, 0.6f, 0.6f); glBegin(GL_POINTS);
00245     for ( n = 1; n < NUMSTARS; n += 3 ) glVertex3dv(stars[n]); glEnd();
00246     glColor3f(0.7f, 0.7f, 0.7f); glBegin(GL_POINTS);
00247     for ( n = 2; n < NUMSTARS; n += 3) glVertex3dv(stars[n]); glEnd();
00248     TERMINAR_LISTA();
00249 #endif
00250 }
00251 
00252 #ifdef GL_ENABLED
00253 void
00254 FONDO_ESTRELLAS::pintar_gl(CAMARA *Camara)
00263 {
00264     if ( nuevito ) init();
00265 
00266     COLOR negro(0, 0, 0);
00267 
00268     PONER_FONDO_COLOR(negro);
00269     glMatrixMode(GL_PROJECTION);    glPushMatrix();
00270     Camara->activar_centro_gl();
00271     glMatrixMode(GL_MODELVIEW);     glPushMatrix();      glLoadIdentity();
00272     glPushAttrib(GL_ALL_ATTRIB_BITS); glCallList(lista_gl); glPopAttrib();
00273     glPopMatrix();
00274     glMatrixMode(GL_PROJECTION);    glPopMatrix();           
00275     glMatrixMode(GL_MODELVIEW);                              
00276 }
00277 #endif
00278 
00279 BOOLEAN
00280 FONDO_ESTRELLAS::leer(TOKENIZADOR *Sabiondo)
00281 {
00282     char cad[1000];
00283     int tipo_token = TK_DESCONOCIDO, pos;
00284 
00285     pos = 2;
00286     while ( tipo_token != TK_CERRAR ) {
00287         tipo_token = Sabiondo->siguiente_token(cad);
00288         switch ( pos ) {
00289          /*
00290             case 1:
00291               ESPERO(TK_CADENA, "una cadena");
00292               if ( strlen(cad) > MAX_CAD-1 ) cad[MAX_CAD-1] = '\0'; 
00293               des_comille(cad);
00294               set_nombre(cad);
00295               pos++;
00296               break;*/
00297             case 2:  ESPERO(TK_ABRIR, "\"{\"");  pos++; break;
00298             default:
00299               if ( tipo_token == TK_CERRAR ) break;
00300               ESPERO(TK_IDENTIFICADOR, "un identificador (2)");
00301               /*
00302               if ( strstr(cad, "material") ) {
00303                   tipo_token = Sabiondo->siguiente_token(cad);
00304                   ESPERO(TK_CADENA, "una cadena");
00305                   leer_material(cad);
00306                 }
00307                 else if ( strcmp(cad, "resortes_tipo1") == 0 ) {
00308                     if ( !leer_resortes(Sabiondo, 0) ) return FALSE;
00309                 }
00310               */
00311               ;
00312               break;
00313         }
00314     }
00315 
00316     return TRUE;
00317 }
00318 
00319 //===========================================================================
00320 //= CLASE FONDO_ATMOSFERICO                                                 =
00321 //===========================================================================
00322 
00323 FONDO_ATMOSFERICO::FONDO_ATMOSFERICO() : FONDO() {
00324     ;
00325 }
00326 
00327 FONDO_ATMOSFERICO::~FONDO_ATMOSFERICO() {
00328     ;
00329 }
00330 
00331 void
00332 FONDO_ATMOSFERICO::init(void)
00335 {
00336     ;
00337 }
00338 
00339 #ifdef GL_ENABLED
00340 void
00341 FONDO_ATMOSFERICO::pintar_gl(CAMARA * /*Camara*/)
00344 {
00345     COLOR color(0.5f, 0.3f, 0.15f);
00346 
00347     PONER_FONDO_COLOR(color);
00348 }
00349 #endif
00350 
00351 BOOLEAN
00352 FONDO_ATMOSFERICO::leer(TOKENIZADOR *Sabiondo)
00353 {
00354     char cad[1000];
00355     int tipo_token = TK_DESCONOCIDO, pos;
00356 
00357     pos = 2;
00358     while ( tipo_token != TK_CERRAR ) {
00359         tipo_token = Sabiondo->siguiente_token(cad);
00360         switch ( pos ) {
00361          /*
00362             case 1:
00363               ESPERO(TK_CADENA, "una cadena");
00364               if ( strlen(cad) > MAX_CAD-1 ) cad[MAX_CAD-1] = '\0'; 
00365               des_comille(cad);
00366               set_nombre(cad);
00367               pos++;
00368               break;*/
00369             case 2:  ESPERO(TK_ABRIR, "\"{\"");  pos++; break;
00370             default:
00371               if ( tipo_token == TK_CERRAR ) break;
00372               ESPERO(TK_IDENTIFICADOR, "un identificador (2)");
00373 /*
00374               if ( strstr(cad, "material") ) {
00375                   tipo_token = Sabiondo->siguiente_token(cad);
00376                   ESPERO(TK_CADENA, "una cadena");
00377                   leer_material(cad);
00378                 }
00379                 else if ( strcmp(cad, "resortes_tipo1") == 0 ) {
00380                     if ( !leer_resortes(Sabiondo, 0) ) return FALSE;
00381                 }
00382               ;*/
00383               break;
00384         }
00385     }
00386 
00387     return TRUE;
00388 }
00389 
00390 //===========================================================================
00391 //= CLASE FONDO_MAPA_DE_ENTORNO                                             =
00392 //===========================================================================
00393 
00394 FONDO_MAPA_DE_ENTORNO::FONDO_MAPA_DE_ENTORNO() : FONDO() 
00395 {
00396     int i;
00397 
00398     for ( i = 0; i < 6; i++ ) {
00399         parches[i] = NULL;
00400     }
00401 
00402 }
00403 
00404 FONDO_MAPA_DE_ENTORNO::~FONDO_MAPA_DE_ENTORNO() 
00405 {
00406     int i;
00407 
00408     for ( i = 0; i < 6; i++ ) {
00409         if ( parches[i] ) {
00410             delete parches[i];
00411             parches[i] = NULL;
00412         }
00413     }
00414     if ( prefijo ) {
00415         delete prefijo;
00416         prefijo = NULL;
00417     }
00418 }
00419 
00420 void
00421 FONDO_MAPA_DE_ENTORNO::init(void)
00424 {
00425     prefijo = NULL;
00426 }
00427 
00428 #ifdef GL_ENABLED
00429 void
00430 FONDO_MAPA_DE_ENTORNO::pintar_gl(CAMARA *Camara)
00433 {
00434     //-----------------------------------------------------------------------
00435     COLOR c(1, 0, 0);
00436     PONER_FONDO_COLOR(c);
00437 
00438     glMatrixMode(GL_PROJECTION);    glPushMatrix();
00439     Camara->activar_centro_gl();
00440     glMatrixMode(GL_MODELVIEW);     glPushMatrix();
00441 
00442     glDisable(GL_DITHER);
00443     glDisable(GL_LIGHTING);
00444     glDisable(GL_DEPTH_TEST);
00445 
00446     CALIDAD_VISUAL calidad;
00447     MATERIAL material;
00448 
00449     calidad.con_textura = TRUE;
00450     calidad.con_caras = TRUE;
00451     calidad.con_bordes = FALSE;
00452     calidad.calidad_caras = CVC_CONSTANTE;
00453 
00454     //-----------------------------------------------------------------------
00455 
00456     glLoadIdentity();  glTranslated(0, 0, 1);  glRotated(180, 1, 0, 0);
00457     parches[5]->pintar_gl(&calidad, &material);
00458 
00459     glLoadIdentity();  glTranslated(0, 0, -1);
00460     parches[4]->pintar_gl(&calidad, &material);
00461 
00462     glLoadIdentity();  glTranslated(1, 0, 0);
00463     glRotated(90, 1, 0, 0); glRotated(-90, 0, 1, 0);
00464     parches[1]->pintar_gl(&calidad, &material);
00465 
00466     glLoadIdentity();  glTranslated(-1, 0, 0);
00467     glRotated(90, 1, 0, 0); glRotated(90, 0, 1, 0);
00468     parches[3]->pintar_gl(&calidad, &material);
00469 
00470     glLoadIdentity(); glTranslated(0, 1, 0);  glRotated(90, 1, 0, 0);
00471     parches[0]->pintar_gl(&calidad, &material);
00472 
00473     glLoadIdentity();  glTranslated(0, -1, 0);
00474     glRotated(180, 0, 1, 0); glRotated(-90, 1, 0, 0);
00475     parches[2]->pintar_gl(&calidad, &material);
00476 
00477     //-----------------------------------------------------------------------
00478     glEnable(GL_DITHER);
00479     glEnable(GL_DEPTH_TEST);
00480     glPopMatrix();
00481     glMatrixMode(GL_PROJECTION);    glPopMatrix();           
00482     glMatrixMode(GL_MODELVIEW);                              
00483 }
00484 #endif
00485 
00486 /*
00487 void
00488 FONDO_MAPA_DE_ENTORNO::pintar_povray(FILE *fd)
00489 {
00490     COLOR c(1, 0, 0);
00491 
00492     fprintf(fd,
00493         "background { color rgb <%f, %f, %f> }\n", c.r, c.g, c.b
00494     );
00495 }
00496 */
00497 
00498 static IMAGEN_RGB *
00499 cargar_imagen(char *archivo)
00500 {
00501     IMAGEN_RGB *Img;
00502     FILE *fd;
00503 
00504     fd = fopen(archivo, "rb");
00505     if ( !fd ) {
00506         fprintf(stderr, "ERROR: No se puede abrir el archivo!\n");
00507         fflush(stderr);
00508         return NULL;
00509     }
00510     Img = new IMAGEN_RGB();
00511     if ( !Img->importar_ppm(fd) ) {
00512         fprintf(stderr, "ERROR: No se puede crear el bitmap IMG!\n");
00513         fflush(stderr); delete Img; 
00514         return NULL;
00515     }
00516     fclose(fd);
00517     return Img;
00518 }
00519 
00520 BOOLEAN
00521 FONDO_MAPA_DE_ENTORNO::leer(TOKENIZADOR *Sabiondo)
00522 {
00523     char cad[1000];
00524     int tipo_token = TK_DESCONOCIDO, pos;
00525 
00526     pos = 2;
00527     while ( tipo_token != TK_CERRAR ) {
00528         tipo_token = Sabiondo->siguiente_token(cad);
00529         switch ( pos ) {
00530          /*
00531             case 1:
00532               ESPERO(TK_CADENA, "una cadena");
00533               if ( strlen(cad) > MAX_CAD-1 ) cad[MAX_CAD-1] = '\0'; 
00534               des_comille(cad);
00535               set_nombre(cad);
00536               pos++;
00537               break;*/
00538             case 2:  ESPERO(TK_ABRIR, "\"{\"");  pos++; break;
00539             default:
00540               if ( tipo_token == TK_CERRAR ) break;
00541               ESPERO(TK_IDENTIFICADOR, "un identificador (2)");
00542               if ( strstr(cad, "prefijo") ) {
00543                   tipo_token = Sabiondo->siguiente_token(cad);
00544                   ESPERO(TK_CADENA, "una cadena");
00545                   des_comille(cad);
00546                   prefijo = new char[strlen(cad)+1];
00547                   strcpy(prefijo, cad);
00548                 }
00549               ;
00550               break;
00551         }
00552     }
00553 
00554     //-----------------------------------------------------------------------
00555     if ( !prefijo ) {
00556         fprintf(stderr,"<FONDO_MAPA_DE_ENTORNO> No se tiene un prefijo!\n");
00557         fflush(stderr);
00558         return FALSE;
00559     }
00560 
00561     IMAGEN_RGB *Img = NULL;
00562     int i;
00563 
00564     for ( i = 0; i < 6; i++ ) {
00565         sprintf(cad, "%s%d.ppm", prefijo, i);
00566         Img = cargar_imagen(cad);
00567         if ( !Img ) {
00568             fprintf(stderr,
00569                 "<FONDO_MAPA_DE_ENTORNO> ERROR cargando la imagen \"%s\".\n",
00570                  cad);
00571             fflush(stderr);
00572             return FALSE;
00573         }
00574         parches[i] = new CUADRICULA(2, 2);
00575         parches[i]->copiar_textura(Img);
00576         delete Img;
00577     }
00578 
00579 
00580     return TRUE;
00581 }
00582 
00583 //===========================================================================
00584 //= EOF                                                                     =
00585 //===========================================================================
00586
fondo.C
