terreno.C

Ir a la documentación de este archivo.

//===========================================================================
//= terreno.cc                                              Octubre de 1999 =
//=-------------------------------------------------------------------------=
//= Definicion de la clase TERRENO                                          =
//=-------------------------------------------------------------------------=
//= ADVERTENCIA: ESTE SOFTWARE NO ESTA CONCEBIDO NI DISENNADO PARA EL USO   =
//= EN EQUIPO DE CONTROL EN LINEA EN ENTORNOS PELIGROSOS QUE REQUIERAN UN   =
//= DESEMPENNO LIBRE DE FALLAS, COMO LA OPERACION DE PLANTAS NUCLEARES,     = 
//= SISTEMAS DE NAVEGACION O COMUNICACION EN AVIONES, TRAFICO AEREO,        =
//= EQUIPO MEDICO DEL CUAL DEPENDAN VIDAS HUMANAS O SISTEMAS DE ARMAMENTO,  =
//= EN LOS CUALES UNA FALLA EN EL SOFTWARE PUEDA IMPLICAR DIRECTAMENTE LA   =
//= MUERTE, DANNOS PERSONALES O DANNOS FISICOS Y/O AMBIENTALES GRAVES       =
//= ("ACTIVIDADES DE ALGO RIESGO").                                         =
//=-------------------------------------------------------------------------=
//= Autor original: Oscar J. Chavarro G.  A.K.A. JEDILINK. Copyright (c),   =
//= 1997 - 2003, oscarchavarro@hotmail.com                                  =
//= AQUYNZA es software libre, y se rige bajo los terminos de la licencia   =
//= LGPL de GNU (http://www.gnu.org). Para mayor informacion respecto a la  =
//= licencia de uso, consulte el archivo ./doc/LICENCIA en la distribucion. =
//===========================================================================

#include "toolkits/geom/geometria.h"
#include "lista.cc"

#ifdef VEL_ROSITA
    #include "toolkits/geom/terreno.h"
#endif

#include <stdio.h>
#include <stdlib.h>

//===========================================================================
//= Opciones de compilacion!                                                =
//===========================================================================

// (1/3) GL_COMPLETO viene de otra parte...
//#undef GL_COMPLETO

// (2/3)
#define TRUCO_FAZ

// (3/3) No use NATURAL = FALSE sin GL_COMPLETO (!)
#define NATURAL
#ifndef GL_COMPLETO
  #define NATURAL
#endif

//===========================================================================
//= Constantes y macros                                                     =
//===========================================================================

#define FACTOR 5000

#define VERIFICAR(p,c)                                            \
    if ( !(p) ) {                                               \
        fprintf(stderr, "<TERRENO> ERROR: No hay memoria para %s!\n", (c));  \
        fflush(stderr);                                         \
        exit(1);                                                \
    }

// OJO: Este `*EEE` es un machete!
#define EEE 10
#define ALTURA_MUESTRA_PA_NORMALES(x, y) (vertices_arr[(y)*_x_tam+(x)].z*EEE)

//===========================================================================
//= Variables globales                                                      =
//===========================================================================

static int normal_pattern[9][6] = {
    {0, 0, 0, 0, 0, 8},  // tipo 0
    {0, 0, 0, 2, 2, 4},  // tipo 1
    {0, 0, 0, 4, 4, 0},  // tipo 2
    {2, 2, 0, 0, 0, 4},  // tipo 3
    {1, 1, 2, 1, 1, 2},  // tipo 4
    {0, 0, 4, 2, 2, 0},  // tipo 5
    {4, 4, 0, 0, 0, 0},  // tipo 6
    {2, 2, 4, 0, 0, 0},  // tipo 7
    {0, 0, 8, 0, 0, 0}   // tipo 8
};

static int lados_primarios[6][2] = {
    {1, 0}, {1, -1}, {0, -1}, {-1, 0}, {-1, 1}, {0, 1}  };
static int lados_secundarios[6][2] = {
    {1, -1}, {0, -1}, {-1, 0}, {-1, 1}, {0, 1}, {1, 0}  };

//===========================================================================
//= Clase TERRENO                                                           =
//===========================================================================

TERRENO::TERRENO(GLOBAL_DEM *Fuente,
        long int origen_x, long int origen_y, long int xtam, long int ytam,
        double escala, double exageracion)
{
    //- Mensaje de depuracion: guia de que esta activo y que no -------------
    #ifdef NONONO
    printf("Opciones de compilacion:\n"); fflush(stdout);
    #ifdef GL_COMPLETO
    printf("  - GL_COMPLETO: TRUE\n"); fflush(stdout);
    #endif
    #ifndef GL_COMPLETO
    printf("  - GL_COMPLETO: FALSE\n"); fflush(stdout);
    #endif
    #ifdef NATURAL
    printf("  - NATURAL: TRUE\n"); fflush(stdout);
    #endif
    #ifndef NATURAL
    printf("  - NATURAL: FALSE\n"); fflush(stdout);
    #endif
    #ifdef TRUCO_FAZ
    printf("  - TRUCO_FAZ: TRUE\n"); fflush(stdout);
    #endif
    #ifndef TRUCO_FAZ
    printf("  - TRUCO_FAZ: FALSE\n"); fflush(stdout);
    #endif
    #endif

    //- Preparativos basicos ------------------------------------------------
    imagen = NULL;
    VERIFICAR(Fuente, "una fuente");
    _escala = escala;
    _factor_exageracion = exageracion;

    //- Importacion de la geometria del terreno (vertices) ------------------
    long int i;

    _x_tam = xtam;
    _y_tam = ytam;
    vertices_tam = xtam * ytam;
    vertices_arr = new VERTICE_GL[vertices_tam];
    VERIFICAR(vertices_arr, "el arreglo de vertices");

    Fuente->exportar_vertices(vertices_arr, origen_x, origen_y, xtam, ytam);

    for ( i = 0; i < vertices_tam; i++ ) {
        vertices_arr[i].y += 1000; // Esto corre dos fila.  Recuerde que las
                                   // celdas son de 1000 * 1000 metros.
        vertices_arr[i].x -= 1000;
        // Tenga en cuenta que una escala de 1/50K convierte cuadros de un
        // km^2 a un tamanno "manejable" (a escala de metros)...
        vertices_arr[i].x *= (float)escala;
        vertices_arr[i].y *= (float)escala;
        vertices_arr[i].z *= (float)escala*(float)_factor_exageracion;
    }

    //- Calculo del min-max -------------------------------------------------
    int x, y;

    _min.x = INFINITO;
    _min.y = INFINITO;
    _min.z = INFINITO;
    _max.x = -INFINITO;
    _max.y = -INFINITO;
    _max.z = -INFINITO;
    for ( y = 1; y < _y_tam-1; y++ ) {
        for ( x = 1; x < _x_tam-1; x++ ) {
            i = _x_tam * y + x;
            if ( vertices_arr[i].x < _min.x ) _min.x = vertices_arr[i].x;
            if ( vertices_arr[i].y < _min.y ) _min.y = vertices_arr[i].y;
            if ( vertices_arr[i].z < _min.z ) _min.z = vertices_arr[i].z;
            if ( vertices_arr[i].x > _max.x ) _max.x = vertices_arr[i].x;
            if ( vertices_arr[i].y > _max.y ) _max.y = vertices_arr[i].y;
            if ( vertices_arr[i].z > _max.z ) _max.z = vertices_arr[i].z;
        }
    }

    //- Cree el arreglo de colores ------------------------------------------
    colores_arr = new GLubyte[vertices_tam*3];
    VERIFICAR(colores_arr, "el arreglo de colores");
    set_paleta(NULL);

    //- Especificacion de la topologia del terreno (tiras de triangulos) ----
    TIras_arr = new GLuint *[_y_tam - 3];
    VERIFICAR(TIras_arr, "las tiras de triangulos");
    for ( y = 0; y < _y_tam-3; y+=
             #ifdef TRUCO_FAZ
              2
             #endif
             #ifndef TRUCO_FAZ
              1
             #endif
    ) {
        TIras_arr[y] = new GLuint[2*(_x_tam - 2)];
        VERIFICAR(TIras_arr[y], "una tira de triangulos");
        for ( x = 0; x < _x_tam-2; x++ ) {
            // Dos vertices: (x+1, y+2) y (x+1, y+1)
            TIras_arr[y][2*x] = _x_tam*(y+2)+x+1;
            TIras_arr[y][2*x+1] = _x_tam*(y+1)+x+1;
        }
    }

#ifdef TRUCO_FAZ
    for ( y = 1; y < _y_tam-3; y+=2 ) {
        TIras_arr[y] = new GLuint[2*(_x_tam - 2)];
        VERIFICAR(TIras_arr[y], "una tira de triangulos");
        for ( x = _x_tam - 3; x >= 0; x-- ) {
            // Dos vertices: (x+1, y+1) y (x+1, y+2)
            TIras_arr[y][2*x+1] = (_x_tam*(y+2)+x+1);
            TIras_arr[y][2*x] = (_x_tam*(y+1)+x+1);
        }
    }
#endif 

    //- Calculo de normales -------------------------------------------------
    VECTOR n(0, 0, 1);
    for ( y = 0; y < _y_tam; y++ ) {
        for ( x = 0; x < _x_tam; x++ ) {
            n = calcule_normal(x, y);
            vertices_arr[y*_x_tam+x].nx = (float)n.x;
            vertices_arr[y*_x_tam+x].ny = (float)n.y;
            vertices_arr[y*_x_tam+x].nz = (float)n.z;
        }
    }
}

void
TERRENO::elim(void)
{
    if ( imagen ) delete imagen;
    if ( vertices_arr ) delete vertices_arr;
    vertices_arr = NULL;
    if ( colores_arr ) delete colores_arr;
    colores_arr = NULL;

    int y;
    if ( TIras_arr ) {
        for ( y = 0; y < _y_tam-3; y++ ) {
            if ( TIras_arr[y] ) delete TIras_arr[y];
            TIras_arr[y] = NULL;
        }
        delete TIras_arr;
        TIras_arr = NULL;
    }
}

TERRENO::~TERRENO()
{
    elim();
}

void
TERRENO::set_paleta(PALETA *P)
{
    Paleta = P;
    int x, y, i;
    float r, g, b;

    for ( y = 1; y < _y_tam-1; y++ ) {
        for ( x = 1; x < _x_tam-1; x++ ) {
            i = _x_tam * y + x;
            calcular_color(vertices_arr[i].z, &r, &g, &b);
            colores_arr[3*i] = (GLubyte)((int)(floor(r*255)));
            colores_arr[3*i+1] = (GLubyte)((int)(floor(g*255)));
            colores_arr[3*i+2] = (GLubyte)((int)(floor(b*255)));
        }
    }
}


//= Operaciones del calculo de normales =====================================

VECTOR
TERRENO::calcule_subnormal(int x1, int y1, int x2, int y2, int x3, int y3)
{
    VECTOR sub_normal, a, b;
    VECTOR p1; 
    VECTOR p2;
    VECTOR p3;

    p1.x = (float)x1;
    p1.y = (float)y1;
    p1.z = (float)ALTURA_MUESTRA_PA_NORMALES(x1, y1);
    p2.x = (float)x2;
    p2.y = (float)y2;
    p2.z = (float)ALTURA_MUESTRA_PA_NORMALES(x2, y2);
    p3.x = (float)x3;
    p3.y = (float)y3;
    p3.z = (float)ALTURA_MUESTRA_PA_NORMALES(x3, y3);

    a.x = (p2.x - p1.x);
    a.y = (p2.y - p1.y);
    a.z = (p2.z - p1.z);
    b.x = (p3.x - p1.x);
    b.y = (p3.y - p1.y);
    b.z = (p3.z - p1.z);

    sub_normal = a.producto_cruz(b);
    sub_normal.normalizar();

    return sub_normal;
}

VECTOR
TERRENO::calcule_normal(int x, int y)
{
    VECTOR normal(0, 0, 0);

    //- Clasificacion del vertice -------------------------------------------
    int tipo;

    if ( y == _y_tam - 1 && x == _x_tam - 1 ) tipo = 8;
    else if ( y == 0 && x == _x_tam - 1 ) tipo = 2;
    else if ( x == 0 && y == _y_tam - 1 ) tipo = 6;
    else if ( y == 0 && x == 0 ) tipo = 0;
    else if ( y == _y_tam - 1 ) tipo = 7;
    else if ( y == 0 ) tipo = 1;
    else if ( x == _x_tam - 1 ) tipo = 5;
    else if ( x == 0 ) tipo = 3;
    else tipo = 4;

    //- Calculo del promedio ponderado entre las normales incidentes --------
    int t, contribucion;

    for ( t = 0; t < 6; t++ ) {  // Recorra los triangulos incidentes en (x,y)
        contribucion = normal_pattern[tipo][t];
        if ( contribucion > 0 ) {
            VECTOR sub_normal = calcule_subnormal(
                x,                           y, 
                x + lados_primarios[t][0],   y + lados_primarios[t][1],
                x + lados_secundarios[t][0], y + lados_secundarios[t][1]
            );
            normal.x += sub_normal.x;
            normal.y += sub_normal.y;
            normal.z += sub_normal.z;
        }
    }

    //- Finalle feliz -------------------------------------------------------
    normal = normal * (-1);
    normal.normalizar();
    return normal;
}

//===========================================================================

void
TERRENO::anexar_textura(IMAGEN *img)
{
  #ifdef GL_ENABLED
    if ( imagen ) delete imagen;
    imagen = img;
  #endif
}

int
TERRENO::clasificar_punto(VECTOR p)
{
    double d = DISTANCIA(0, 0, 0, p.x, p.y, p.z);

    if ( IGUAL(1, d ) ) {
        return 0;
      }
      else if ( d < 1 ) {
        return 1;
    }
    return -1; // Notese que este es el caso "else", no usar else para que
               // esta funcion siempre retorne algo de manera explicita...
}

void
TERRENO::minmax(VECTOR *min, VECTOR *max)
{
    min->x = _min.x;
    min->y = _min.y;
    min->z = _min.z;
    max->x = _max.x;
    max->y = _max.y;
    max->z = _max.z;
}

void
TERRENO::calcular_color(float z, float *r, float *g, float *b)
{
    z /= (float)_factor_exageracion;
    //-----------------------------------------------------------------------
    double val;
    COLOR c;

    if ( Paleta ) {
        // El monte mas alto esta por debajo de 10000 metros sobre el mar
        val = (z/_escala)/7000 + 0.19; 

        c = Paleta->escala(val);
        (*r) = c.r;
        (*g) = c.g;
        (*b) = c.b;
        return;
    }

    //-----------------------------------------------------------------------
    if ( z <= 0 ) {
        (*r) = 0;
        (*g) = 0;
        (*b) = 1;
      }
      else if ( z*FACTOR < 100 ) {
        (*r) = (float)0.5;
        (*g) = (float)0.8;
        (*b) = (float)0.5;
      }
      else if ( z*FACTOR < 200 ) {
        (*r) = (float)0.5;
        (*g) = (float)0.7;
        (*b) = (float)0.5;
      }
      else if ( z*FACTOR < 500 ) {
        (*r) = (float)0.7;
        (*g) = (float)0.7;
        (*b) = (float)0.5;
      }
      else if ( z*FACTOR< 1000 ) {
        (*r) = (float)0.5;
        (*g) = (float)0.5;
        (*b) = (float)0.3;
      }
      else if ( z*FACTOR < 2000 ) {
        (*r) = (float)0.5;
        (*g) = (float)0.5;
        (*b) = 0;
      }
      else if ( z*FACTOR < 3000 ) {
        (*r) = (float)0.5;
        (*g) = (float)0.5;
        (*b) = (float)0.2;
      }
      else if ( z*FACTOR < 4000 ) {
        (*r) = (float)0.5;
        (*g) = (float)0.5;
        (*b) = (float)0.5;
      }
      else if ( z*FACTOR < 5000 ) {
        (*r) = (float)0.9;
        (*g) = (float)0.9;
        (*b) = (float)0.9;
      }
      else {
        (*r) = 1;
        (*g) = 1;
        (*b) = 1;
      }
    ;
}

#ifdef GL_ENABLED

void
TERRENO::pintar_tiras_gl(void)
{
    //- 1 (opcion A) Natural ------------------------------------------------
#ifdef NATURAL
    int y;

  #ifndef GL_COMPLETO
    float r = 1, g = 0, b = 0;
    int x;

    for ( y = 0; y < _y_tam-3; y++ ) {
      #ifdef TRUCO_FAZ
      if ( y % 2 ) glFrontFace(GL_CW); else glFrontFace(GL_CCW);
      #endif
      glBegin(GL_TRIANGLE_STRIP);
        for ( x = 0; x < _x_tam - 2; x++ ) {
            calcular_color(vertices_arr[TIras_arr[y][2*x]].z, &r, &g, &b);
            glColor3f(r, g, b);
            glNormal3fv(&vertices_arr[TIras_arr[y][2*x]].nx);
            glVertex3fv(&vertices_arr[TIras_arr[y][2*x]].x);

            calcular_color(vertices_arr[TIras_arr[y][2*x+1]].z, &r, &g, &b);
            glColor3f(r, g, b);
            glNormal3fv(&vertices_arr[TIras_arr[y][2*x+1]].nx);
            glVertex3fv(&vertices_arr[TIras_arr[y][2*x+1]].x);
        }
      glEnd();
    }
  #endif

  #ifdef GL_COMPLETO
    glInterleavedArrays(GL_T2F_N3F_V3F, 0, vertices_arr);
    glEnableClientState(GL_COLOR_ARRAY);
    glColorPointer(3, GL_UNSIGNED_BYTE, 0, colores_arr);
    for ( y = 0; y < _y_tam-3; y++ ) {
        #ifdef TRUCO_FAZ
        if ( y % 2 ) glFrontFace(GL_CW); else glFrontFace(GL_CCW);
        #endif
        glDrawElements(GL_TRIANGLE_STRIP,
                    2*(_x_tam - 2), GL_UNSIGNED_INT,
                    TIras_arr[y]);
    }
    glDisable(GL_COLOR_ARRAY);
  #endif
#endif

    //- 1 (opcion B) No Natural ---------------------------------------------
    /* OJO: Esta fallando! */
#ifndef NATURAL
    int y;

    glDisable(GL_LIGHTING); // <-- OJO: Esta es la unica diferencia!
    glInterleavedArrays(GL_T2F_N3F_V3F, 0, vertices_arr);
    glEnableClientState(GL_COLOR_ARRAY);
    glColorPointer(3, GL_UNSIGNED_BYTE, 0, colores_arr);
    for ( y = 0; y < _y_tam-3; y++ ) {
        #ifdef TRUCO_FAZ
        if ( y % 2 ) glFrontFace(GL_CW); else glFrontFace(GL_CCW);
        #endif
        glDrawElements(GL_TRIANGLE_STRIP,
                    2*(_x_tam - 2), GL_UNSIGNED_INT,
                    TIras_arr[y]);
    }
    glDisable(GL_COLOR_ARRAY);
#endif

    //-----------------------------------------------------------------------
    #ifdef TRUCO_FAZ
    glFrontFace(GL_CCW);
    #endif

    //-----------------------------------------------------------------------
#ifdef NONONO
    // Pintar las normales
    glDisable(GL_LIGHTING);
    glColor3f(1, 1, 0);
    for ( y = 0; y < _y_tam-3; y++ ) {
      glBegin(GL_LINES);
        for ( x = 0; x < _x_tam - 2; x++ ) {
            glVertex3f(vertices_arr[y*_x_tam+x].x,
                       vertices_arr[y*_x_tam+x].y,
                       vertices_arr[y*_x_tam+x].z);
        glVertex3f(vertices_arr[y*_x_tam+x].x+vertices_arr[y*_x_tam+x].nx/40,
                   vertices_arr[y*_x_tam+x].y+vertices_arr[y*_x_tam+x].ny/40,
                   vertices_arr[y*_x_tam+x].z+vertices_arr[y*_x_tam+x].nz/40);
        }
      glEnd();
    }
#endif

    //-----------------------------------------------------------------------
#ifdef DEBUG_TERRENO
    VERTICE_GL v;
    int i;

    glDisable(GL_LIGHTING);
    glColor3d(color_debug.r, color_debug.g, color_debug.b);
    for ( i = 0; i < arr_debug_x.tam(); i++ ) {
        glPushMatrix();
        v = vertices_arr[arr_debug_y[i]*_x_tam+arr_debug_x[i]];
        glTranslated(v.x, v.y, v.z);
        pintar_cubo(0.01);
        glPopMatrix();
    }

#endif
}

void
TERRENO::pintar_gl(CALIDAD_VISUAL *Calidad, MATERIAL* Material,
                   CAMARA * /*Camara*/)
{
    //----------------------------------------------------------------------
#ifdef NONONO
    long int i;

    // Pintado de vertices
    glColor3f(1, 1, 1);
    glDisable(GL_LIGHTING);
    glBegin(GL_POINTS);
    for ( i = 0; i < vertices_tam; i++ ) {
        glVertex3fv(&vertices_arr[i].x);
    }
    glEnd();
#endif

    //- Pintado de bordes --------------------------------------------------
    COLOR cb(1, 0, 0);

    if ( Calidad->con_bordes ) {
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
        if ( !Calidad->con_caras ) glDisable(GL_CULL_FACE);
        Calidad->activar_bordes_gl(cb, Material);
        //glShadeModel(GL_SMOOTH);
        pintar_tiras_gl();
    }

    if ( Calidad->con_cajas ) PINTAR_MINMAX_GL();

    //- Pintado de caras ---------------------------------------------------
    COLOR c(1, 1, 1);

    if ( Calidad->con_caras ) {
        glEnable(GL_CULL_FACE);
        glCullFace(GL_BACK);
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        Material->activar_gl();
        Calidad->activar_caras_gl(c, Material);
        if ( imagen && Calidad->con_textura ) {
            imagen->activar_gl();
            glEnable(GL_TEXTURE_2D);
            Calidad->activar_textura_gl();
          }
          else if ( Calidad->con_caustics ) {
            Calidad->activar_textura_gl();
          }
          else {
            glDisable(GL_TEXTURE_2D);
        }

        ACTIVAR_POLYGON_OFFSET();

        glEnable(GL_COLOR_MATERIAL);
        glColorMaterial(GL_FRONT, GL_DIFFUSE);

        pintar_tiras_gl();

        glDisable(GL_COLOR_MATERIAL);

        DESACTIVAR_POLYGON_OFFSET();
        glDisable(GL_TEXTURE_2D);
    }

}
#endif

void
TERRENO::pintar_aqz(FILE *fd)
{
    fprintf(fd, "    // Pilas: No hay pintar_aqz... \n");
    fprintf(fd, "    geometria ESFERA 1 \"\"\n");
}

void
TERRENO::pintar_povray(FILE *fd)
{
    fprintf(fd,
        "sphere {\n"
        "    <0, 0, 0>, %f\n",
        1.0
    );
}

GEOMETRIA *
TERRENO::crear_copia(void)
{
    TERRENO *e;

    e = new TERRENO(NULL, 0, 0, 1, 1, 1, 1);
    VERIFICAR(e, "la copia de la GEOMETRIA");
    if ( !e ) return NULL;

    (*e) = (*this);

    if ( imagen ) {
        e->imagen = imagen->copie();
        if ( !e->imagen ) {
            fprintf(stderr,
            "<TERRENO> Warning: no se pudo replicar una textura.\n");
            fflush(stderr);
        }
    }

    return (GEOMETRIA *)e;
}

#ifdef NONONO
double
TERRENO::altura(double x, double y)
{
    int i, j;

    i = coord2index_x(x);
    j = coord2index_x(y);
    if ( i >= 0 && i < _x_tam &&
         j >= 0 && j < _y_tam ) {
/* OJO: ESTO ESTA MAL! Debe tenerse en cuenta los triangulos... */
// Se puede hacer facil con la operacion de interseccion!
        return vertices_arr[(i) + _x_tam*(j)].z;
    }
    return 0;
}
#endif

BOOLEAN
TERRENO::seleccionar(RAYO *Rayito, int *i, int *j)
{
    VECTOR p, n;
    if ( !interseccion(Rayito, p, n) ) return FALSE;
    p.x += 500*_escala;
    p.y += 500*_escala;
    (*i) = coord2index_x(p.x) + 2; // OJO! porque con + 2?
    (*j) = coord2index_y(p.y) - 1; // OJO! porque con - 1?
    return TRUE;
}


//===========================================================================
//= EOF                                                                     =
//===========================================================================

---

Este archivo HTML ha sido generado automáticamente a partir del código fuente AQUYNZA. NO LO EDITE. Para mayor información contacte al autor.