terreno_lod.C

Ir a la documentación de este archivo.

//===========================================================================
//= terreno.cc                                                Mayo del 2000 =
//=-------------------------------------------------------------------------=
//= Definicion de la clase TERRENO_LOD                                      =
//=-------------------------------------------------------------------------=
//= 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_lod.h"
#endif

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

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

#define FACTOR 5000

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

#ifdef GL_ENABLED
static double x00, y00, z00;

#define RENDER_VERTEX(v) \
    x00 = vertices_arr[((v).y+1)*_x_tam+((v).x+1)].x; \
    y00 = vertices_arr[((v).y+1)*_x_tam+((v).x+1)].y; \
    z00 = vertices_arr[((v).y+1)*_x_tam+((v).x+1)].z; \
    glVertex3d(x00, y00, z00); 
#endif

#define aVERTICE(v) atributos_arr[((v).y)*_x_tam + ((v).x)]
#define VERTICE_VALIDO(v) \
    ((v)->y >= 0 && (v)->y <= _y_tam-3 && (v)->x >= 0 && (v)->x <= _x_tam-3)

// 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}  };

//#define DEBUG_LOD_PADRES 1

#ifdef DEBUG_LOD_PADRES
LISTA <COORDENADA_2D *> LISTA_padres;
#endif

//===========================================================================
//= Funciones utilitarias                                                   =
//===========================================================================

int
potencia2(int entrada)
{
    int i;

    for ( i = 1; i < 32; i++ ) {
        if ( (0x01 << (i-1)) & entrada  ) {
            return i-1;
        }
    }
    return 0;
}

//===========================================================================
//= Clase TERRENO_LOD                                                       =
//===========================================================================

TERRENO_LOD::TERRENO_LOD(GLOBAL_DEM *Fuente,
        long int origen_x, long int origen_y, long int xtam, long int ytam,
        double escala, double exageracion)
{
    //- Preparativos basicos ------------------------------------------------
    imagen = NULL;
    VERIFICAR(Fuente);
    _escala = escala;
    nivel_anterior = 0;
    ptr = 0;

    _factor_exageracion = exageracion;

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

    _x_tam = xtam;
    _y_tam = ytam;
    dimension = potencia2(_x_tam-3);
    vertices_tam = xtam * ytam;
    vertices_arr = new VERTICE_GL[vertices_tam];
    atributos_arr = new _TERRENO_LOD_ATRIBUTO_VERTICE[vertices_tam];

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

    for ( i = 0; i < vertices_tam; i++ ) {
        // Inicializacion de vertices
        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;
        }
    }

    //- 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;
        }
    }
}

TERRENO_LOD::~TERRENO_LOD()
{
    if ( imagen ) delete imagen;
    delete vertices_arr;
}

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

VECTOR
TERRENO_LOD::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_LOD::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_LOD::anexar_textura(IMAGEN *img)
{
  #ifdef GL_ENABLED
    if ( imagen ) delete imagen;
    imagen = img;
  #endif
}

int
TERRENO_LOD::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_LOD::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;
}

#ifdef GL_ENABLED

BOOLEAN
TERRENO_LOD::elem_buffer(COORDENADA_2D &o)
{
    if ( o == buffer[0] || o == buffer[1] ) {
        return TRUE;
    }
    return FALSE;
}

void
TERRENO_LOD::toggle_ptr(void)
{
    if ( ptr == 0 ) ptr = 1;
    else ptr = 0;
}

void
TERRENO_LOD::pintar_cuadrante_gl(COORDENADA_2D l, COORDENADA_2D t, 
                                 COORDENADA_2D r, int nivel)
{
    if ( nivel <= 0 ) return;                    // 1
    if ( !aVERTICE(t).enabled() ) return;        // 2

    pintar_cuadrante_gl(l, (l+r)/2, t, nivel-1); // 3
    if ( !elem_buffer(t) ) {                     // 4
        if ( (nivel + nivel_anterior) % 2 ) {    // 5
            toggle_ptr();                        // 6
          }
          else {                                 // 7
            RENDER_VERTEX(buffer[(ptr+1)%2]);    // 8
        }
        RENDER_VERTEX(t);                        // 9
        buffer[ptr] = t;                         // 10
        nivel_anterior = nivel;                  // 11
    }
    pintar_cuadrante_gl(t, (l+r)/2, r, nivel-1); // 12
}

void
TERRENO_LOD::update_vertex(COORDENADA_2D *v)
{
    //if ( aVERTICE(*v).locked() ) return;                              // 1

    int i;
    COORDENADA_2D parentT0, parentT1;
    int branchT0, branchT1;

    for ( i = 0; i < 4; i++ ) {                                         // 2
        if ( !aVERTICE(*v).dependency(i) ) {                            // 2
            if ( aVERTICE(*v).enabled() != aVERTICE(*v).activated() ) { // 3
                aVERTICE(*v).set_enabled(~aVERTICE(*v).enabled());      // 4
                consultar_padres(v, &parentT0, &parentT1,
                                    &branchT0, &branchT1, 1);
                notify(&parentT0, branchT0, aVERTICE(*v).enabled());    // 5
                notify(&parentT1, branchT1, aVERTICE(*v).enabled());    // 6
            }
        }
    }
}

void
TERRENO_LOD::notify(COORDENADA_2D *v, int child, BOOLEAN state)
{
    if ( !VERTICE_VALIDO(v) ) return;                                   // 1
    aVERTICE(*v).set_dependency(child, state);                          // 2
    //if ( aVERTICE(*v).locked() ) return;                              // 3

    int i;
    COORDENADA_2D parentT0, parentT1;
    int branchT0, branchT1;

    for ( i = 0; i < 4; i++ ) {                                         // 4
        if ( !aVERTICE(*v).dependency(i) ) {                            // 4
            if ( !aVERTICE(*v).activated() ) {                          // 5
                aVERTICE(*v).set_enabled(FALSE);                        // 6
                consultar_padres(v, &parentT0, &parentT1,
                                    &branchT0, &branchT1, 1);
                notify(&parentT0, branchT0, FALSE);                     // 7
                notify(&parentT1, branchT1, FALSE);                     // 8
            }
          }
          else {                                                        // 9
            if ( !aVERTICE(*v).enabled() ) {                            // 10
                aVERTICE(*v).set_enabled(TRUE);                         // 11
                consultar_padres(v, &parentT0, &parentT1,
                                    &branchT0, &branchT1, 1);
                notify(&parentT0, branchT0, TRUE);                      // 12
                notify(&parentT1, branchT1, TRUE);                      // 13
            }

        }
    }
}

void
TERRENO_LOD::consultar_padres(COORDENADA_2D *h, 
                              COORDENADA_2D *p1, COORDENADA_2D *p2, 
                              int *i1, int *i2, int nivel)
{
    int longitud = 0x01 << (nivel-1);
    int x, y;
    int hx, hy;

    hx = h->x / longitud;
    hy = h->y / longitud;
    (*i1) = 666;
    (*i2) = 666;

    if ( (hx%2) == 0 && (hy%2) != 0 ) {
        p1->x = h->x - longitud;
        p1->y = h->y;
        (*i1) = 1;
        p2->x = h->x + longitud;
        p2->y = h->y;
        (*i2) = 3;
      }
      else if ( (hx%2) != 0 && (hy%2) == 0 ) {
        p1->x = h->x;
        p1->y = h->y - longitud;
        (*i1) = 0;
        p2->x = h->x;
        p2->y = h->y + longitud;
        (*i2) = 2;
      }
      else if ( (hx%2) != 0 && (hy%2) != 0 ) {
        x = hx/2;
        y = hy/2;
        if ( (x%2 == 0) && (y%2 == 0) ) {
            p1->x = h->x - longitud;
            p1->y = h->y + longitud;
            (*i1) = 1;
            p2->x = h->x + longitud;
            p2->y = h->y - longitud;
            (*i2) = 3;
          }
          else if ( (x%2 != 0) && (y%2 == 0) ) {
            p1->x = h->x + longitud;
            p1->y = h->y + longitud;
            (*i1) = 2;
            p2->x = h->x - longitud;
            p2->y = h->y - longitud;
            (*i2) = 0;
          }
          else if ( (x%2 == 0) && (y%2 != 0) ) {
            p1->x = h->x - longitud;
            p1->y = h->y - longitud;
            (*i1) = 0;
            p2->x = h->x + longitud;
            p2->y = h->y + longitud;
            (*i2) = 2;
          }
          else if ( (x%2 != 0) && (y%2 != 0) ) {
            p1->x = h->x - longitud;
            p1->y = h->y + longitud;
            (*i1) = 1;
            p2->x = h->x + longitud;
            p2->y = h->y - longitud;
            (*i2) = 3;
          }
        ;
      }
      else {
        if ( nivel >= dimension ) {
            p1->x = -1;
            p1->y = -1;
            p2->x = -1;
            p2->y = -1;
            (*i1) = 4;
            (*i2) = 4;
          }
          else {
            consultar_padres(h, p1, p2, i1, i2, nivel+1);
        }
      }
    ;
}


void
TERRENO_LOD::pintar_tiras_gl(void)
{
    //- Pinte los 4 cuadrantes ---------------------------------------------
    int i, n;
    COORDENADA_2D l, t, r;
    int x_max, y_max;
    static int q[4][3][2] =  {
        {{0, 0}, {1, 1}, {2, 0}},  // Cuadrante q[0]
        {{2, 0}, {1, 1}, {2, 2}},  // Cuadrante q[1]
        {{2, 2}, {1, 1}, {0, 2}},  // Cuadrante q[2]
        {{0, 2}, {1, 1}, {0, 0}}   // Cuadrante q[3]
    };

    //- Preparativos -
    x_max = _x_tam - 3;
    y_max = _y_tam - 3;
    glColor3d(0.0, 0.9, 0.0);
    n = potencia2(x_max);

    //- Adaptacion del macroalgoritmo original del paper... -
    glBegin(GL_TRIANGLE_STRIP);           // 1 Enter triangle mesh mode
    l.x = q[0][0][0]*(x_max/2);           // 2 Render vertex q0l
    l.y = q[0][0][1]*(y_max/2);
    RENDER_VERTEX(l);
    buffer[ptr] = l;                      // 3
    nivel_anterior = 0;                   // 4

    for ( i = 0; i < 4; i++ ) {           // 5
        l.x = q[i][0][0]*(x_max/2);  l.y = q[i][0][1]*(y_max/2);
        t.x = q[i][1][0]*(x_max/2);  t.y = q[i][1][1]*(y_max/2);
        r.x = q[i][2][0]*(x_max/2);  r.y = q[i][2][1]*(y_max/2);

        if ( !(nivel_anterior % 2) ) {    // 6 if previous level is even
            toggle_ptr();                 // 7 toggle ptr
          }
          else {                          // 8
                                          // 9 swap vertices in graphics buffer
            RENDER_VERTEX(buffer[(ptr+1)%2]);
        }
        RENDER_VERTEX(l);                 // 10 Render vertex qil
        buffer[ptr] = l;                  // 11
        nivel_anterior = 2*n + 1;         // 12
        pintar_cuadrante_gl(l,t,r, 2*n);  // 13
    }
    l.x = q[i%4][0][0]*(x_max/2);         // 14 Render vertex q0l
    l.y = q[i%4][0][1]*(y_max/2);
    RENDER_VERTEX(l);
    glEnd();                              // 15

    //-----------------------------------------------------------------------
#ifdef NONONO
    // Pintar las normales
    int y, x;
    glDisable(GL_LIGHTING);
    glColor3f(1, 1, 0);
    for ( y = 1; y < _y_tam-1; y++ ) {
      glBegin(GL_LINES);
        for ( x = 1; x < _x_tam - 1; 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/4,
                   vertices_arr[y*_x_tam+x].y+vertices_arr[y*_x_tam+x].ny/4,
                   vertices_arr[y*_x_tam+x].z+vertices_arr[y*_x_tam+x].nz/4);
        }
      glEnd();
    }
#endif

    //-----------------------------------------------------------------------
#ifdef DEBUG_TERRENO_LOD
    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_LOD::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

    //- Evaluacion del algoritmo de niveles de detalle ---------------------
    int x, y;
    COORDENADA_2D v;

    for ( y = 0; y < _y_tam-2; y++ ) {
        for ( x = 0; x < _x_tam-2; x++ ) {
            v.x = x; v.y = y;
            //if ( x == 3 && y == 0 ) {
            if ( vertices_arr[(v.y+1)*_x_tam+(v.x+1)].z > 0 ) {
                aVERTICE(v).set_activated(TRUE);
              }
              else {
                aVERTICE(v).set_activated(FALSE);
            }
            update_vertex(&v);

            //printf("%.2f ", vertices_arr[(v.y+1)*_x_tam+(v.x+1)].z);

        }
        printf("\n"); fflush(stdout);
    }

#ifdef DEBUG_LOD_PADRES
    COORDENADA_2D *Vv, p1, p2;
    int i1, i2;

    for ( y = 0; y < _y_tam-2; y++ ) {
        for ( x = 0; x < _x_tam-2; x++ ) {
            Vv = new COORDENADA_2D;
            Vv->x = x;  Vv->y = y;
            LISTA_padres.anx(Vv);

            consultar_padres(Vv, &p1, &p2, &i1, &i2, 1);
            Vv = new COORDENADA_2D;
            Vv->x = p1.x;  Vv->y = p1.y;
            LISTA_padres.anx(Vv);       

            Vv = new COORDENADA_2D;
            Vv->x = p2.x;  Vv->y = p2.y;
            LISTA_padres.anx(Vv);       
        }
    }
#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);
    }

    //-----------------------------------------------------------------------
#ifdef DEBUG_LOD_PADRES
    long int iii, i;
    double xx=0.0, yy=0.0, zz=0.0;
    double px=0.0, py=0.0, pz=0.0;
    double dx=0.02, dy=0.02, dz=0.05;

    // Pintado de padres
    glDisable(GL_LIGHTING);
    glDisable(GL_DEPTH_TEST);
    for ( i = 0; i < LISTA_padres.tam(); i += 3 ) {
        // pinto el centro
        if ( VERTICE_VALIDO(LISTA_padres[i]) ) {
            iii = (LISTA_padres[i]->y+1) * _x_tam + (LISTA_padres[i]->x+1);
            xx= vertices_arr[iii].x;
            yy= vertices_arr[iii].y;
            zz= vertices_arr[iii].z;
            glColor3f(1, 0, 0);
            glBegin(GL_LINES);
            glVertex3f(xx-dx, yy-dy, zz+dz);
            glVertex3f(xx+dx, yy+dy, zz+dz);
            glVertex3f(xx-dx, yy+dy, zz+dz);
            glVertex3f(xx+dx, yy-dy, zz+dz);
            glEnd();
        }

        // pinto el padre 1
        if ( VERTICE_VALIDO(LISTA_padres[i+1]) ) {
            iii = (LISTA_padres[i+1]->y+1) * _x_tam + (LISTA_padres[i+1]->x+1);
            px= vertices_arr[iii].x;
            py= vertices_arr[iii].y;
            pz= vertices_arr[iii].z;
            glColor3f(1, 0.5, 0.7);
            glBegin(GL_LINES);
            glVertex3f(xx, yy, zz+dz);
            glVertex3f(px, py, pz);
            glEnd();
        }

        // pinto el padre 2
        if ( VERTICE_VALIDO(LISTA_padres[i+2]) ) {
            iii = (LISTA_padres[i+2]->y+1) * _x_tam + (LISTA_padres[i+2]->x+1);
            px= vertices_arr[iii].x;
            py= vertices_arr[iii].y;
            pz= vertices_arr[iii].z;
            glColor3f(1, 0.7, 0.5);
            glBegin(GL_LINES);
            glVertex3f(xx, yy, zz+dz);
            glVertex3f(px, py, pz+2*dz);
            glEnd();
        }

    }

    for ( i = 0; i < LISTA_padres.tam(); i++ ) {
        delete LISTA_padres[i];
    }
    LISTA_padres.elim();
    glEnable(GL_DEPTH_TEST);
#endif


}
#endif

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

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

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

    e = new TERRENO_LOD(NULL, 0, 0, 1, 1, 1, 1);
    if ( !e ) return NULL;

    (*e) = (*this);

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

    return (GEOMETRIA *)e;
}

#ifdef NONONO
double
TERRENO_LOD::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_LOD::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.