bsp_2d.C

Ir a la documentación de este archivo.

//===========================================================================
//= bsp_2d.cc                       Noviembre/diciembre 1997, Junio de 1999 =
//=-------------------------------------------------------------------------=
//= Clases de representacion de interiores de solidos rigidos modelados por =
//= la frontera, con enfasis en espacios arquitectonicos sencillos.         =
//= Esquema de representacion compatible con los niveles de juego DOOM-WAD  =
//= de idSoftware.                                                          =
//= Notese que este modulo esta organizado en 3 grandes secciones:          =
//=   - Definicion de una representacion geometrica tipo BREP               =
//=   - Definicion de una particion espacial binaria (BSP) sobre dicha      =
//=     estructura geometrica                                               =
//=   - Definicion de la estructura publica que encapsula y exporta los     =
//=     servicios de la representacion a los demas modulos AQUYNZA.         =
//= Cabe la posibilidad de que este modulo este sobrepasando los limites de =
//= manejabilidad, por ser tan grande y complejo.  En caso de decidir sub-  =
//= dividirlo en mas modulos, se propone que se subdivida en tres, uno para =
//= cada una de las actuales secciones.                                     =
//=-------------------------------------------------------------------------=
//= 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 <ctype.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>

#include "jed_gl.h"
#include "toolkits/geom/bsp_2d.h"
#include "matriz4.h"
#include "triangulate.h"
#include "lista.cc"

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

#ifdef GL_ENABLED
static GLenum PRIMITIVA_triangulos = GL_TRIANGLES;
static GLenum PRIMITIVA_cuadros = GL_QUADS;
static int NUM_poligonos;  // Esto esta aqui para hacer pruebas para medir
                           // el funcionamiento de la estructura BSP.
#endif

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

#define BIT_15  (1 << 15)
#define FX 0.95
#define ESCALA_ALTURA 1.28

#define A_METROS(recuadro) (  ((double)(recuadro) - 32768.0)/50.0  )
#define A_RECUADROS(metros) ( (WORD)(50 * metros + 32768.0)  )

#define PINTAR_VERTICE(v, altura) \
     glVertex3d( A_METROS((v).x), A_METROS((v).y), ESCALA_ALTURA*A_METROS((altura+32768)) );

#define CORREGIR(v) \
    if ( (v)  > 32768 ) (v) -= 32768; else (v) += 32768;

#define VERIFIQUE(var, mensaje, cantidad) \
    if ( !var ) { \
        fprintf(stderr, mensaje, cantidad); \
        fflush(stdout); \
        return FALSE; \
    }

#define CHEQUEO_WAD(pointer, mensaje)                                     \
    if ( !(pointer) ) {                                                   \
        fprintf(stderr, "<BSP_2D> - ERROR FATAL: \n    %s\n", (mensaje)); \
        return FALSE;                                                     \
    }

#define PINTAR_RECTA(q, v)                                              \
    glBegin(GL_LINES);                                                  \
        glVertex3d((q).x, (q).y, (q).z+0.01);                           \
        glVertex3d((q).x + (v).x, (q).y + (v).y, (q).z + (v).z+0.01);   \
    glEnd();

#define ACTIVAR_TEXTURA_PARED(textura_id)               \
    if ( (textura_id) >= 0 &&                           \
         Calidad->con_textura && Calidad->con_caras ) { \
        Padre->sprites[(textura_id)]->activar_gl();     \
    }

//===========================================================================
//= Servicios varios locales a este modulo                                  =
//===========================================================================

static inline BOOLEAN
se_intersectan(VECTOR q1, VECTOR v1,
               VECTOR q2, VECTOR v2)
{
    double numerador, denominador, t;
    denominador = v1.x*v2.y - v1.y*v2.x;
    if ( fabs(denominador) < EPSILON ) return FALSE;
    numerador = (v2.x*(q1.y-q2.y)) + (v2.y*(q2.x - q1.x));
    t = numerador/denominador;
    if ( t < 0 ) return FALSE;
    return TRUE;
}

//===========================================================================
//= INFORMACION GENERAL RESPECTO A LAS CLASES                               =
//=-------------------------------------------------------------------------=
//= Debe notarse que la mayoria de clases tienen dos metodos en comun:      =
//=     void importe_wad(WAD_LEVEL *Nivel_wad, WORD pos);    y              =
//=     void pintar_gl(const _BSP2D_VERTICEi min, const _BSP2D_VERTICEi max);        =
//= El metodo importe_wad lee a partir de un archivo WAD de IdSoftware los  =
//= datos necesarios para el pos-esimo objeto, verificando el rango de pos  =
//= y la existencia real de datos.  Obtenga mayor informacion en la         =
//= documentacion de DOOM y en las clases del modulo jedi_wad.              =
//= El metodo pintar_gl ejecuta primitivas del Api OpenGL.                   =
//===========================================================================


//=*************************************************************************=
//= PRIMERA SECCION: CLASES DE LA REPRESENTACION GEOMETRICA BREP            =
//=-------------------------------------------------------------------------=
//= Aqui se encuentran, en este orden, las siguientes clases:               =
//=   - _BSP2D_ARCO                                                         =
//=   - _BSP2D_PARED                                                        =
//=   - _BSP2D_SEGMENTOi                                                     =
//=   - _BSP2D_SECTOR                                                       =
//=*************************************************************************=

//===========================================================================
//= Clase _BSP2D_ARCO                                                       =
//===========================================================================

_BSP2D_ARCO::_BSP2D_ARCO()
{
    Padre = NULL;
    Izq = NULL;
    Der = NULL;
}

void
_BSP2D_ARCO::importe_wad(BSP_2D *p, WAD_LEVEL *Nivel_wad, long int pos)
{
    Padre = p;

    if ( !Nivel_wad->Linedefs ) {
        fprintf(stderr, "ERROR FATAL: No se tienen arcos (LINEDEFS)!\n");
        fflush(stderr);
        return;
    }

    if ( pos > (Nivel_wad->Linedefs->size)/14 ) {
        fprintf(stderr, 
                "Warning: El arco (LINEDEF) %ld esta fuera de rango!\n", pos);
        fflush(stderr);
        return;
    }

    BYTE dummy[14];
    WORD temp;

    fseek(Nivel_wad->wad_fd, Nivel_wad->Linedefs->offset + pos*14, SEEK_SET);
    lea_WORD_BE(&v_origen, Nivel_wad->wad_fd);
    lea_WORD_BE(&v_destino, Nivel_wad->wad_fd);
    lea_WORD_BE(&flags, Nivel_wad->wad_fd);

    fread(dummy, sizeof(BYTE), 2, Nivel_wad->wad_fd);

    lea_WORD_BE(&sector_id, Nivel_wad->wad_fd);

    lea_WORD_BE(&temp, Nivel_wad->wad_fd);
    //if ( temp != 0xFFFF ) {
        if ( (long int)temp > (long int)Padre->num_paredes ) {
            fprintf(stderr, "Warning: Referencia a pared %d fuera de rango.\n",
                    temp);
            fflush(stderr);
        }
        else {
            Der = &(Padre->Paredes[temp]);
            Der->Arco_padre = this;
            Der->Del_otro_lado = NULL;
        }
    //}

    lea_WORD_BE(&temp, Nivel_wad->wad_fd);
    //if ( temp != 0xFFFF ) {
        if ( temp > Padre->num_paredes ) {
            fprintf(stderr, "Warning: Referencia a pared %d fuera de rango.\n",
                    temp);
            fflush(stderr);
        }
        else {
            Izq = &(Padre->Paredes[temp]);
            Izq->Arco_padre = this;
            Izq->Del_otro_lado = Der;
            Der->Del_otro_lado = Izq;
        }
    //}
    //else {
    //    Izq = NULL;
    //}
}

#ifdef GL_ENABLED
void
_BSP2D_ARCO::pintar_gl_3D(void)
{
    _BSP2D_VERTICEi v;
    WORD altura = 0;
    float r, g, b;

    if ( ARCO_IMPASABLE(*this) ) {
        r = 1;  g = 0; b = 0;
    }
    else {
        r = 0.5; g = 0.5; b = 0;
    }

    if ( ARCO_SECRETO(*this) ) {
        r /= 2; g /= 2; b /= 2;
    }

    glColor3f(r, g, b);

    v = Padre->Vertices[v_origen];
    PINTAR_VERTICE(v, altura);
    v = Padre->Vertices[v_destino];
    PINTAR_VERTICE(v, altura);
}
#endif

//===========================================================================
//= Clase _BSP2D_PARED                                                      =
//===========================================================================

_BSP2D_PARED::_BSP2D_PARED()
{
    Arco_padre = NULL;
    Del_otro_lado = NULL;
}

void
_BSP2D_PARED::importe_wad(BSP_2D *Padre, WAD_LEVEL *Nivel_wad, long int pos)
{
    if ( !Nivel_wad->Sidedefs ) {
        fprintf(stderr, "ERROR FATAL: No se tienen paredes (SIDEDEFS)!\n");
        fflush(stderr);
        return;
    }

    if ( pos > (Nivel_wad->Sidedefs->size)/30 ) {
        // OJO: Este test esta fallando mucho! Revisar.
        fprintf(stderr, 
       "<_BSP2D_PARED/BSP_2D> Warning: La pared (SIDEDEF) %ld esta fuera de rango!\n",
        pos);
        fflush(stderr);
        return;
    }

    fseek(Nivel_wad->wad_fd, Nivel_wad->Sidedefs->offset + pos*30, SEEK_SET);

    lea_WORD_BE(&dx, Nivel_wad->wad_fd);
    lea_WORD_BE(&dy, Nivel_wad->wad_fd);
    fread(textura_superior, sizeof(BYTE), 8, Nivel_wad->wad_fd);
    fread(textura_inferior, sizeof(BYTE), 8, Nivel_wad->wad_fd);
    fread(textura_media, sizeof(BYTE), 8, Nivel_wad->wad_fd);
    textura_superior[8] = textura_inferior[8] = textura_media[8] = '\0';
    lea_WORD_BE(&sector_id, Nivel_wad->wad_fd);

    textura_superior_id = Padre->deme_textura(textura_superior);
    textura_media_id =    Padre->deme_textura(textura_media);
    textura_inferior_id = Padre->deme_textura(textura_inferior);
}

void
_BSP2D_PARED::calcule_normal(void)
{
    //- Precalcule datos de vertices -----------------------------------------
    v1 = Arco_padre->Padre->Vertices[Arco_padre->v_origen];
    v2 = Arco_padre->Padre->Vertices[Arco_padre->v_destino];
    altura1 = Arco_padre->Padre->Sectores[sector_id].altura_piso;
    altura2 = Arco_padre->Padre->Sectores[sector_id].altura_techo;

    //- Precalcule el vector normal a esta pared -----------------------------
    VECTOR a, b;

    a.x = A_METROS(v1.x); a.y = A_METROS(v1.y); a.z = A_METROS(altura1+32768);
    b.x = A_METROS(v2.x); b.y = A_METROS(v2.y); b.z = A_METROS(altura1+32768);

    n = b.producto_cruz(a);
    if ( n.z < 0 ) {
        n.x = -n.x;
        n.y = -n.y;
        n.z = -n.z;
    }
    n.normalizar();
}

#ifdef GL_ENABLED
void
_BSP2D_PARED::pintar_gl_3D(void)
{
    WORD otra_altura1;
    WORD otra_altura2;

    if ( ARCO_IMPASABLE(*Arco_padre) ) {
        glBegin(PRIMITIVA_cuadros);
            glNormal3d(n.x, n.y, n.z);
            PINTAR_VERTICE(v1, altura1);
            PINTAR_VERTICE(v2, altura1);
            PINTAR_VERTICE(v2, altura2);
            PINTAR_VERTICE(v1, altura2);
        glEnd();
      }
      else if ( ARCO_DOBLE_CARA(*Arco_padre) ) {
        // OJO: No se verifica que haya pared del otro lado!

        otra_altura1 = Del_otro_lado->altura1;
        if ( otra_altura1 > altura1 ) {
            glBegin(PRIMITIVA_cuadros);
                glNormal3d(n.x, n.y, n.z);
                PINTAR_VERTICE(v1, altura1);
                PINTAR_VERTICE(v2, altura1);
                PINTAR_VERTICE(v2, otra_altura1);
                PINTAR_VERTICE(v1, otra_altura1);
            glEnd();
        }
        otra_altura2 = Del_otro_lado->altura2;
        if ( otra_altura2 < altura2 ) {
            glBegin(PRIMITIVA_cuadros);
                glNormal3d(n.x, n.y, n.z);
                PINTAR_VERTICE(v1, otra_altura2);
                PINTAR_VERTICE(v2, otra_altura2);
                PINTAR_VERTICE(v2, altura2);
                PINTAR_VERTICE(v1, altura2);
            glEnd();
        }
     }
     else {
        /*
        glDisable(GL_LIGHTING);
        glColor3f(1, 0, 0);
        glBegin(GL_LINES);
            glNormal3d(n.x, n.y, n.z);
            PINTAR_VERTICE(v1, altura1);
            PINTAR_VERTICE(v2, altura1);
            PINTAR_VERTICE(v2, altura2);
            PINTAR_VERTICE(v1, altura2);
        glEnd();
        glEnable(GL_LIGHTING);
        */
      }
    ;
}
#endif

//===========================================================================
//= Clase BSP2D_SEGMENTOi                                                   =
//===========================================================================

_BSP2D_SEGMENTOi::_BSP2D_SEGMENTOi()
{
    angulo_recta = 0;
}

void
_BSP2D_SEGMENTOi::importe_wad(BSP_2D *pp, WAD_LEVEL *Nivel_wad, long int pos)
{
    Padre = pp;

    if ( !Nivel_wad->Segs ) {
        fprintf(stderr, "ERROR FATAL: No se tienen sub-sectores!\n");
        fflush(stderr);
        return;
    }

    if ( pos > (Nivel_wad->Segs->size)/12 ) {
        fprintf(stderr,
                "Warning: El segmento %ld esta fuera de rango!\n", pos);
        fflush(stderr);
        return;
    }

    fseek(Nivel_wad->wad_fd, Nivel_wad->Segs->offset + pos*12, SEEK_SET);

    lea_WORD_BE(&v_origen, Nivel_wad->wad_fd);
    lea_WORD_BE(&v_destino, Nivel_wad->wad_fd);
    lea_WORD_BE(&angulo, Nivel_wad->wad_fd);
    lea_WORD_BE(&arco_i, Nivel_wad->wad_fd);
    lea_WORD_BE(&direccion, Nivel_wad->wad_fd);
    lea_WORD_BE(&offset, Nivel_wad->wad_fd);

    // Preprocesamiento de datos...
    angulo_recta = (((PI/2)/16384.0) * angulo) + DEG2RAD(180);
    if ( v_origen == Padre->Arcos[arco_i].v_origen ) {
        Pared = Padre->Arcos[arco_i].Der;
      }
      else {
        // OJO: Porque?
        Pared = Padre->Arcos[arco_i].Der;
    }

    // OJO: Esto no se sabe si funciona!
    // Se asume que los vertices y el angulo de este segmento ya estan
    // precalculados, haciendo la informacion de direccion, arco y offset
    // redundante (y por ende aqui no se usa) (!).
    /*
      WORD tmp;
      if ( direccion ) {
      tmp = v_origen;
      v_origen = v_destino;
      v_destino = tmp;
      }*/

    _BSP2D_PARED *p;
    // Determine el sector al que bordea
    if ( !direccion ) {
            // Soy el lado derecho
        p = Padre->Arcos[arco_i].Der;
    }
    else {
        // Soy un lado izquierdo
        p = Padre->Arcos[arco_i].Izq;
    }
    if ( !p ) {
        fprintf(stderr, "Warning: direccion incorrecta sobre el arco %d.\n",
                arco_i);
        fflush(stdout);
        sector_id = 0;
        return;
    }
    sector_id = p->sector_id;
}

#ifdef GL_ENABLED
void
_BSP2D_SEGMENTOi::pintar_gl_2D(double angulo_camara)
{
    //- 1. Algoritmo de back-face culling! ---------------------------------
    double fov = 85;  // OJO: Toca des-cablear esto!

    if ( cos(angulo_camara - angulo_recta) < -cos(DEG2RAD(fov)) ) return;

    //- 2. Pintado de vectores de guia (ayuda para el desarrollador!) ------
    _BSP2D_VERTICEi v, medio_i, medio_f;

#ifdef NONONO
    // Verificacion de vertices (normalmente desactivado por eficiencia)
    if ( v_origen >= Padre->num_vertices || 
         v_destino >= Padre->num_vertices ) {
        fprintf(stderr, "ERROR: Vertices (%d, %d) fuera de rango\n", 
                v_origen, v_destino);
        fflush(stderr);
        return;
    }
#endif

    //glLineWidth(1.0f);

#ifdef NONONO
    // Pintar un vector de direccion del segmento
    glColor3f(0, 1, 0);
    glBegin(GL_LINES);
        medio_i.x=(Padre->Vertices[v_origen].x+Padre->Vertices[v_destino].x)/2;
        medio_i.y=(Padre->Vertices[v_origen].y+Padre->Vertices[v_destino].y)/2;
        PINTAR_VERTICE(medio_i, 1);

        medio_f.x = medio_i.x + (int)(20.0 * sin(angulo_recta));
        medio_f.y = medio_i.y - (int)(20.0 * cos(angulo_recta));
        PINTAR_VERTICE(medio_f, 1);
    glEnd();
#endif

    // Pintar la rayita de orientacion
    glColor3f(0, 0, 1);
    glBegin(GL_LINES);
        double a = (PI/2) * ((long int) angulo) / 16384;
        medio_i.x=(Padre->Vertices[v_origen].x+Padre->Vertices[v_destino].x)/2;
        medio_i.y=(Padre->Vertices[v_origen].y+Padre->Vertices[v_destino].y)/2;
        PINTAR_VERTICE(medio_i, 1);

        medio_f.x = medio_i.x + (int)(20.0 * sin(a));
        medio_f.y = medio_i.y - (int)(20.0 * cos(a));
        PINTAR_VERTICE(medio_f, 1);
    glEnd();

#ifdef NONONO
    // Pintar el vector de orientacion de la camara
    if ( cos(angulo_camara - angulo_recta) > -cos(DEG2RAD(fov)) )
    glColor3f(0, 1, 1); else glColor3f(0, 0.3, 0.3);
    glBegin(GL_LINES);
        PINTAR_VERTICE(medio_i, 1);
        medio_f.x = medio_i.x + (int)(20.0 * sin(angulo_camara));
        medio_f.y = medio_i.y - (int)(20.0 * cos(angulo_camara));
        PINTAR_VERTICE(medio_f, 1);
    glEnd();
#endif

    //- 3. Pintar el segmento en si -----------------------------------------
    glBegin(GL_LINES);
        glColor3f(1, 0, 0);
        v = Padre->Vertices[v_origen];
        PINTAR_VERTICE(v, 1);

        v = Padre->Vertices[v_destino];
        PINTAR_VERTICE(v, 1);
    glEnd();

    NUM_poligonos++;
}

void
_BSP2D_SEGMENTOi::pintar_gl_3D(CALIDAD_VISUAL *Calidad, double angulo_camara)
{
    //- 1. Algoritmo de back-face culling! ---------------------------------
    double fov = 60;  // OJO: Toca des-cablear esto!

    if ( cos(angulo_camara - angulo_recta) < -cos(DEG2RAD(fov)) ) return;

    //- 2. Pintar el segmento en si -----------------------------------------
    WORD otra_altura1;
    WORD otra_altura2;
    double u1, u2, u3, u4;
    double v1, v2, v3, v4;
    double u, v, d, du, dv;
    IMAGEN *Img;

    if ( ARCO_IMPASABLE(Padre->Arcos[arco_i]) ) {
        ACTIVAR_TEXTURA_PARED(Pared->textura_media_id);
        //-------------------------------------------------------------------
        Img = Padre->sprites[Pared->textura_media_id];
        d = DISTANCIA(A_METROS(Padre->Vertices[v_origen].x), 
                      A_METROS(Padre->Vertices[v_origen].y), 0,
                      A_METROS(Padre->Vertices[v_destino].x),
                      A_METROS(Padre->Vertices[v_destino].y), 0);
        u = d / ((double)Img->xtam()/50.0);
        v = (A_METROS(Pared->altura2) - A_METROS(Pared->altura1))/((double)Img->ytam()/50.0);
        du = ((double)Pared->dx)/128.0;
        dv = -((double)Pared->dy)/128.0;
        u1 = -(u+du);     v1 = (1-v) + dv;
        u2 = -du;         v2 = (1-v) + dv;
        u3 = -du;         v3 = 1 + dv;
        u4 = -(u+du);     v4 = 1 + dv;
        //-------------------------------------------------------------------
        glBegin(PRIMITIVA_cuadros);
            glNormal3d(Pared->n.x, Pared->n.y, Pared->n.z);
            glTexCoord2d(u1, v1);
            PINTAR_VERTICE(Padre->Vertices[v_origen], Pared->altura1);
            glTexCoord2d(u2, v2);
            PINTAR_VERTICE(Padre->Vertices[v_destino], Pared->altura1);
            glTexCoord2d(u3, v3);
            PINTAR_VERTICE(Padre->Vertices[v_destino], Pared->altura2);
            glTexCoord2d(u4, v4);
            PINTAR_VERTICE(Padre->Vertices[v_origen], Pared->altura2);
        glEnd();
        //-------------------------------------------------------------------
      }
      else if ( ARCO_DOBLE_CARA(Padre->Arcos[arco_i]) ) {
        // OJO: No se verifica que haya pared del otro lado!
        if ( !Pared->Del_otro_lado ) {
            fprintf(stderr, "<_BSP2D_SEGMENTOi> No hay pared del otro lado!"); 
            fflush(stderr);
        }
        otra_altura1 = Pared->Del_otro_lado->altura1;
        if ( otra_altura1 > Pared->altura1 ) {
            ACTIVAR_TEXTURA_PARED(Pared->textura_inferior_id);
            //---------------------------------------------------------------
            Img = Padre->sprites[Pared->textura_inferior_id];
            d = DISTANCIA(A_METROS(Padre->Vertices[v_origen].x), 
                          A_METROS(Padre->Vertices[v_origen].y), 0,
                          A_METROS(Padre->Vertices[v_destino].x),
                          A_METROS(Padre->Vertices[v_destino].y), 0);
            u = d / (Img->xtam()/50.0);
            v = (A_METROS(Pared->altura2) - A_METROS(Pared->altura1))/(Img->ytam()/25.0);
            du = ((double)Pared->dx)/128.0;
            dv = -((double)Pared->dy)/128.0;
            u1 = -(u+du);     v1 = (1-v) + dv;
            u2 = -du;         v2 = (1-v) + dv;
            u3 = -du;         v3 = 1 + dv;
            u4 = -(u+du);     v4 = 1 + dv;
            //---------------------------------------------------------------
            glBegin(PRIMITIVA_cuadros);
                glNormal3d(Pared->n.x, Pared->n.y, Pared->n.z);
                glTexCoord2d(u1, v1);
                PINTAR_VERTICE(Padre->Vertices[v_origen], Pared->altura1);
                glTexCoord2d(u2, v2);
                PINTAR_VERTICE(Padre->Vertices[v_destino], Pared->altura1);
                glTexCoord2d(u3, v3);
                PINTAR_VERTICE(Padre->Vertices[v_destino], otra_altura1);
                glTexCoord2d(u4, v4);
                PINTAR_VERTICE(Padre->Vertices[v_origen], otra_altura1);
            glEnd();
            //---------------------------------------------------------------
        }
        otra_altura2 = Pared->Del_otro_lado->altura2;
        if ( otra_altura2 < Pared->altura2 ) {
            ACTIVAR_TEXTURA_PARED(Pared->textura_superior_id);
            //---------------------------------------------------------------
            Img = Padre->sprites[Pared->textura_superior_id];
            d = DISTANCIA(A_METROS(Padre->Vertices[v_origen].x), 
                          A_METROS(Padre->Vertices[v_origen].y), 0,
                          A_METROS(Padre->Vertices[v_destino].x),
                          A_METROS(Padre->Vertices[v_destino].y), 0);
            u = d / (Img->xtam()/50.0);
            v = (A_METROS(Pared->altura2) - A_METROS(Pared->altura1))/(Img->ytam()/50.0);
            du = ((double)Pared->dx)/128.0;
            dv = -((double)Pared->dy)/128.0;
            u1 = -(u+du);     v1 = (1-v) + dv;
            u2 = -du;         v2 = (1-v) + dv;
            u3 = -du;         v3 = 1 + dv;
            u4 = -(u+du);     v4 = 1 + dv;
            //---------------------------------------------------------------
            glBegin(PRIMITIVA_cuadros);
                glNormal3d(Pared->n.x, Pared->n.y, Pared->n.z);
                glTexCoord2d(u1, v1);
                PINTAR_VERTICE(Padre->Vertices[v_origen], otra_altura2);
                glTexCoord2d(u2, v2);
                PINTAR_VERTICE(Padre->Vertices[v_destino], otra_altura2);
                glTexCoord2d(u3, v3);
                PINTAR_VERTICE(Padre->Vertices[v_destino], Pared->altura2);
                glTexCoord2d(u4, v4);
                PINTAR_VERTICE(Padre->Vertices[v_origen], Pared->altura2);
            glEnd();
            //---------------------------------------------------------------
        }
      }
    ;

    // Como yo me veo, mi piso y mi techo deben verse
    Padre->Sectores[sector_id].marcado = TRUE;

    NUM_poligonos++;
}
#endif // GL_ENABLED

void
_BSP2D_SEGMENTOi::anexe_vertices(LISTA <_BSP2D_VERTICEi *> *Vertices)
{
    Vertices->anx(&Padre->Vertices[v_origen]);
    Vertices->anx(&Padre->Vertices[v_destino]);
}

//===========================================================================
//= Clase _BSP2D_SECTOR                                                     =
//===========================================================================

int
triangularice_cara(int answer[][3], double *Vertices, int nvertices, 
                   int *contour_sizes, int ncontours)
{
    int num_vertices, nmonpoly;

        /* Prepare segments */
    num_vertices = 
        prepare_segments(Vertices, nvertices, contour_sizes, ncontours);

        /* Do the trick */
    initialise(num_vertices);
    construct_trapezoids(num_vertices);
    nmonpoly = monotonate_trapezoids(num_vertices);
    return triangulate_monotone_polygons(num_vertices, nmonpoly, answer);
}

void
_BSP2D_SECTOR::triangularize(void)
{
    long int i, j;
    LISTA <_BSP2D_ARCO *> arcos;
    LISTA <_BSP2D_CONTORNOi *> cOntornos;
    _BSP2D_CONTORNOi *Contorno;
    _BSP2D_ARCO *Arco;
    WORD v_i, v_tmp;

    //- Seleccione los arcos que son de este sector -------------------------
    for ( i = 0, j = 0; i < Padre->num_paredes; i++ ) {
        if ( Padre->Paredes[i].sector_id == pos ) {
            Arco = new _BSP2D_ARCO(); // OJO: Porque?
            (*Arco) = (*Padre->Paredes[i].Arco_padre);
            arcos.anx(Arco);
            if ( Arco->Der == &(Padre->Paredes[i]) ) {
                v_tmp = Arco->v_origen;
                Arco->v_origen = Arco->v_destino;
                Arco->v_destino = v_tmp;
            }
            j++;
        }
    }

    //- Arme contornos ------------------------------------------------------
    while ( arcos.tam() > 0 ) {
        Contorno = new _BSP2D_CONTORNOi;
        Contorno->arcos.anx(arcos[0]);
        arcos.elimElem(0);

        for ( v_i = Contorno->arcos[0]->v_destino; TRUE;
              v_i = Contorno->arcos[Contorno->arcos.tam()-1]->v_destino ) {
            for ( i = 0; i < (long int)arcos.tam(); i++ ) {
                if ( arcos[i]->v_origen == v_i ) {
                    Contorno->arcos.anx(arcos[i]);
                    arcos.elimElem(i);
                    i = 0; break;
                }
            }
            if ( i >= (long int)arcos.tam() ) {
                break;
            }
        }
        if ( Contorno->arcos[0]->v_origen != 
             Contorno->arcos[Contorno->arcos.tam()-1]->v_destino ||
             Contorno->arcos.tam() < 3 ) {
                // Arcos extrannos encontrados comunmente en la estructura de
                // niveles WAD de IdSoftware que no definen sectores.
            delete Contorno;
        }
        else {
            cOntornos.anx(Contorno);
        }
    }

    //- Valide los contornos -----------------------------------------------
    //- OJO: Este segmento es un machete.  Parece que en los niveles de DOOM
    //- hay algunas irregularidades, como pares de arcos que parten en dos a
    //- el borde de su sector (y dannando contornos).
    for ( i = 0; i < (long int)cOntornos.tam(); i++ ) {
        Contorno = cOntornos[i];

        // Quite lineas contiguas que se sobre-rayan la una a la otra
        for ( j = 0; j < (long int)Contorno->arcos.tam() - 1; j++ ) {
            if (Contorno->arcos[j]->v_origen==Contorno->arcos[j+1]->v_destino
                 &&
                Contorno->arcos[j+1]->v_origen==Contorno->arcos[j]->v_destino){
                Contorno->arcos.elimElem(j);
                Contorno->arcos.elimElem(j);
                j--;
            }
        }
        //
    }

    // Elimine contornos nulos
    for ( i = 0; i < (long int)cOntornos.tam(); i++ ) {
        if ( cOntornos[i]->arcos.tam() <= 0 ) {
            cOntornos.elimElem(i);
            i--;
        }
    }
    if ( cOntornos.tam() <= 0 ) {
        return;
    }

    //- Triangularice esta cara! -------------------------------------------
    int nvertices, *contour_sizes;
    long int ncontours; /* Conversion a polygon */
    long int ntriangles;
    double *Vertices;
    int op[500][3], vertice_actual;
    _BSP2D_VERTICEi vert;

    ncontours = cOntornos.tam();
    contour_sizes = new int[ncontours];
    for ( i = 0; i < ncontours; i++ ) {
        contour_sizes[i] = cOntornos[i]->arcos.tam();
    }

    nvertices = 0;
    for ( i = 0; i < (long int)cOntornos.tam(); i++ ) {
        for ( j = 0; j < (long int)cOntornos[i]->arcos.tam(); j++ ) {
            nvertices++;
        }
    }
    Vertices = new double[2*nvertices];
    for ( i = 0, vertice_actual = 0; i < (long int)cOntornos.tam(); i++ ) {
        for ( j = 0; j < (long int)cOntornos[i]->arcos.tam();
              j++, vertice_actual++ ) {
            vert = Padre->Vertices[cOntornos[i]->arcos[j]->v_origen];
            Vertices[2*vertice_actual] = A_METROS(vert.x);
            Vertices[2*vertice_actual+1] = A_METROS(vert.y);
        }
    }

        //
        /*printf("There are %d vertices in %d contours!\n", nvertices, ncontours);
          printf("The contours sizes are:\n    ");
          for ( i = 0; i < ncontours; i++ ) {
          printf("%d ", contour_sizes[i]);
          }
          printf("\n");
          printf("The vertices are:\n");
          for ( i = 0; i < nvertices; i++ ) {
          printf("  - (%.2f, %.2f)\n", Vertices[2*i], Vertices[2*i+1]);
          }
          fflush(stdout);*/

    //
    ntriangles = triangularice_cara(op, 
                                    Vertices, nvertices, contour_sizes, ncontours);
    //
    /*for ( i = 0; i < ntriangles; i++ ) {
      printf("triangle #%d: %d %d %d\n", i, op[i][0], op[i][1], op[i][2]);
      }*/
    //

    //- Deje armaditos los triangulos ----------------------------------------
    num_triangulos = ntriangles;
    Triangulos = new double[6*num_triangulos];

    for ( i = 0; i < ntriangles; i++ ) {
        Triangulos[6*i]   = Vertices[2*(op[i][0]-1)];
        Triangulos[6*i+1] = Vertices[2*(op[i][0]-1)+1];
        Triangulos[6*i+2] = Vertices[2*(op[i][1]-1)];
        Triangulos[6*i+3] = Vertices[2*(op[i][1]-1)+1];
        Triangulos[6*i+4] = Vertices[2*(op[i][2]-1)];
        Triangulos[6*i+5] = Vertices[2*(op[i][2]-1)+1];
    }
    // Calcule min-max (que sera usado por el metodo altura)
    min_x = min_y = FLT_MAX;  max_x = max_y = FLT_MIN;
    for ( i = 0; i < 3*ntriangles; i++ ) {
        if ( Triangulos[2*i] > max_x ) max_x = Triangulos[2*i];
        if ( Triangulos[2*i] < min_x ) min_x = Triangulos[2*i];
        if ( Triangulos[2*i+1] > max_y ) max_y = Triangulos[2*i+1];
        if ( Triangulos[2*i+1] < min_y ) min_y = Triangulos[2*i+1];
    }

    //- Elimine las estructuras de datos temporales ------------------------
    delete Vertices;    delete contour_sizes;
    for ( i = 0; i < (long int)cOntornos.tam(); i++ ) delete cOntornos[i];
    for ( i = 0; i < (long int)arcos.tam(); i++ ) delete arcos[i];
}

BOOLEAN
_BSP2D_SECTOR::altura(double x, double y, double *Altura)
{
    if ( x < min_x || x > max_x || y < min_y || y > max_y ) {
        return FALSE;
    }

    long int i;
    VECTOR p, p1, p2, p3, u, v, w, a, b, c;
    p.x = x, p.y = y;
    p1.z = p2.z = p3.z = p.z = 0;
    for ( i = 0; i < num_triangulos; i++ ) {
        p1.x = Triangulos[6*i];  p1.y = Triangulos[6*i+1];
        p2.x = Triangulos[6*i+2];  p2.y = Triangulos[6*i+3];
        p3.x = Triangulos[6*i+4];  p3.y = Triangulos[6*i+5];
        u = p2 - p1; v = p3 - p2; w = p1 - p3;
        a = p - p1;  b = p - p2; c = p - p3;
        if ( (u.producto_cruz(a)).z > 0 && 
             (v.producto_cruz(b)).z > 0 &&
             (w.producto_cruz(c)).z > 0 ) {
            (*Altura) = A_METROS(32768 + altura_piso);
            return TRUE;
        }
    }
    return FALSE;
}


_BSP2D_SECTOR::_BSP2D_SECTOR()
{
    marcado = FALSE;
    con_paredes = FALSE;
}

void
_BSP2D_SECTOR::importe_wad(BSP_2D *pp, WAD_LEVEL *Nivel_wad, long int p)
{
    Padre = pp;

    if ( !Nivel_wad->Sectors ) {
        fprintf(stderr, "ERROR FATAL: No se tienen paredes (SIDEDEFS)!\n");
        fflush(stderr);
        return;
    }

    if ( pos > (Nivel_wad->Sectors->size)/26 ) {
        fprintf(stderr, 
                "Warning: La pared (SIDEDEF) %ld esta fuera de rango!\n", pos);
        fflush(stderr);
        return;
    }

    pos = p;
    fseek(Nivel_wad->wad_fd, Nivel_wad->Sectors->offset + pos*26, SEEK_SET);

    lea_WORD_BE(&altura_piso, Nivel_wad->wad_fd);
    lea_WORD_BE(&altura_techo, Nivel_wad->wad_fd);
    fread(textura_piso, sizeof(BYTE), 8, Nivel_wad->wad_fd);
    fread(textura_techo, sizeof(BYTE), 8, Nivel_wad->wad_fd);
    textura_piso[8] = textura_techo[8] = '\0';
    lea_WORD_BE(&id, Nivel_wad->wad_fd);

    // - 
    textura_piso_id = Padre->deme_flat(textura_piso);
    textura_techo_id = Padre->deme_flat(textura_techo);
}

#ifdef GL_ENABLED
void
_BSP2D_SECTOR::pintar_gl_3D(CALIDAD_VISUAL *Calidad)
{
    long int i;
    double a;

    // Factor de escalamiento del espacio [u, v] (pixels) al espacio [i, j, k]
    double FT = 1.2; // Ojo: Deberia ser 1.4
    // Incrementos de la coodenada de la textura en el espacio [u,v]
    double IU = 0;   // OJO: Deberian ser 0, 0
    double IV = -0.3;

    if ( !marcado ) return;

    //- Pintar el piso ------------------------------------------------------
    if ( Calidad->con_textura && Calidad->con_caras ) {
        Padre->flats[textura_piso_id]->activar_gl();
    }

    glNormal3d(0, 0, 1);
    glBegin(PRIMITIVA_triangulos);
    a = ESCALA_ALTURA*A_METROS(altura_piso + 32768);
    for ( i = 0; i < num_triangulos; i++ ) {
        glTexCoord2d(Triangulos[6*i]/FT + IU,    Triangulos[6*i+1]/FT + IV);
        glVertex3d(  Triangulos[6*i],            Triangulos[6*i+1], a     );
        glTexCoord2d(Triangulos[6*i+2]/FT + IU,  Triangulos[6*i+3]/FT + IV);
        glVertex3d(  Triangulos[6*i+2],          Triangulos[6*i+3], a     );
        glTexCoord2d(Triangulos[6*i+4]/FT + IU,  Triangulos[6*i+5]/FT + IV);
        glVertex3d(  Triangulos[6*i+4],          Triangulos[6*i+5], a     );
    }
    glEnd();

    //- Pintar el techo -----------------------------------------------------
    if ( Calidad->con_textura && Calidad->con_caras ) {
        Padre->flats[textura_techo_id]->activar_gl();
    }

    glNormal3d(0, 0, 1);
    glBegin(PRIMITIVA_triangulos);
    a = ESCALA_ALTURA*A_METROS(altura_techo + 32768);
    for ( i = 0; i < num_triangulos; i++ ) {
        glTexCoord2d(Triangulos[6*i]/FT + IU,   Triangulos[6*i+1]/FT + IV);
        glVertex3d(  Triangulos[6*i],           Triangulos[6*i+1], a     );
        glTexCoord2d(Triangulos[6*i+4]/FT + IU, Triangulos[6*i+5]/FT + IV);
        glVertex3d(  Triangulos[6*i+4],         Triangulos[6*i+5], a     );
        glTexCoord2d(Triangulos[6*i+2]/FT + IU, Triangulos[6*i+3]/FT + IV);
        glVertex3d(  Triangulos[6*i+2],         Triangulos[6*i+3], a     );
    }
    glEnd();


    //- Pintar las paredes (usando arcos) -----------------------------------
    if ( con_paredes ) {
        // Solo ocurre si no estamos en modo BSP
        // OJO: Deberian recorrerse los segmentos para que las paredes
        //      salgan con texturas!
        for ( i = 0; i < Padre->num_paredes; i++ ) {
            if ( Padre->Paredes[i].sector_id == pos ) {
                Padre->Paredes[i].pintar_gl_3D();
            }
        }
    }
    marcado = FALSE;
}
#endif // GL_ENABLED

//=*************************************************************************=
//= SEGUNDA SECCION: PARTICION BINARIA DEL ESPACIO                          =
//=-------------------------------------------------------------------------=
//= Aqui se encuentran, en este orden, las siguientes clases:               =
//=   - _BSP2D_ELEMENTO                                                      =
//=   - _BSP2D_HOJA                                                          =
//=   - _BSP2D_NODO                                                          =
//=*************************************************************************=

//===========================================================================
//= Clase _BSP2D_ELEMENTO                                                    =
//===========================================================================

_BSP2D_ELEMENTO::_BSP2D_ELEMENTO()
{
    mi_tipo = '\0';
}

_BSP2D_ELEMENTO::~_BSP2D_ELEMENTO()
{
    ;
}

void
_BSP2D_ELEMENTO::init(BSP_2D *p)
{
    Padre = p;
}

//===========================================================================
//= Clase _BSP2D_HOJA                                                        =
//===========================================================================

_BSP2D_HOJA::_BSP2D_HOJA()
{
    mi_tipo = 'h';
}

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

void
_BSP2D_HOJA::elim(void)
{

}

void
_BSP2D_HOJA::mover(_BSP2D_VERTICEi /*delta*/)
{
    ;
}

void
_BSP2D_HOJA::importe_wad(WAD_LEVEL *Nivel_wad, long int pos)
{
    if ( !Nivel_wad->Ssectors ) {
        fprintf(stderr, "ERROR FATAL: No se tienen sub-sectores!\n");
        fflush(stderr);
        return;
    }

    if ( pos > (Nivel_wad->Ssectors->size)/4 ) {
        fprintf(stderr, 
                "Warning: El subsector %ld esta fuera de rango!\n", pos);
        fflush(stderr);
        return;
    }

    fseek(Nivel_wad->wad_fd, Nivel_wad->Ssectors->offset + pos*4, SEEK_SET);

    lea_WORD_BE(&num_segmentos, Nivel_wad->wad_fd);
    lea_WORD_BE(&primer_segmento, Nivel_wad->wad_fd);
}

#ifdef GL_ENABLED
void
_BSP2D_HOJA::pintar_gl_2D(
    VECTOR /*posicion_camara*/,
    VECTOR orientacion_camara, CALIDAD_VISUAL * /*Calidad*/)
{
    WORD i;

    orientacion_camara.normalizar();

    double cam;
    if ( orientacion_camara.y < 0 ) cam=asin(orientacion_camara.x);
    else cam = DEG2RAD(180)-asin(orientacion_camara.x);

    for ( i = primer_segmento; 
          i < primer_segmento + num_segmentos && 
              i < (WORD)Padre->num_segmentos; i++ ) {
        Padre->Segmentos[i].pintar_gl_2D(cam);
    }
}

void
_BSP2D_HOJA::pintar_gl_3D(
    VECTOR /*posicion_camara*/,
    VECTOR orientacion_camara, CALIDAD_VISUAL *Calidad)
{
    WORD i;

    orientacion_camara.normalizar();

    double cam;
    if ( orientacion_camara.y < 0 ) cam=asin(orientacion_camara.x);
    else cam = DEG2RAD(180)-asin(orientacion_camara.x);

    for ( i = primer_segmento; 
          i < primer_segmento + num_segmentos && 
              i < (WORD)Padre->num_segmentos; i++ ) {
        Padre->Segmentos[i].pintar_gl_3D(Calidad, cam);
    }
}
#endif // GL_ENABLED

double
_BSP2D_HOJA::altura_cuadro(WORD /*x*/, WORD /*y*/)
{
    WORD id = Padre->Segmentos[primer_segmento].sector_id;

    return A_METROS(Padre->Sectores[id].altura_piso+32768);
}

//===========================================================================
//= Clase _BSP2D_NODO                                                        =
//===========================================================================

_BSP2D_NODO::_BSP2D_NODO()
{
    mi_tipo = 'n';

    min_izq.x = 400;     min_izq.y = 1600;
    max_izq.x = 900;     max_izq.y = 4000;
    min_der.x = 1000;     min_der.y = 1600;
    max_der.x = 3000;     max_der.y = 4000;

    linea_x = linea_y = 1000;
    linea_dx = linea_dy = 500;
}

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

void
_BSP2D_NODO::elim(void)
{
    Izq->elim();
    Der->elim();
}

void
_BSP2D_NODO::mover(_BSP2D_VERTICEi delta)
{
    min_izq.x += delta.x;     min_izq.y += delta.y;
    max_izq.x += delta.x;     max_izq.y += delta.y;

    min_der.x += delta.x;     min_der.y += delta.y;
    max_der.x += delta.x;     max_der.y += delta.y;

    linea_x += delta.x;       linea_y += delta.y;

    Izq->mover(delta);  Der->mover(delta);
}

void
_BSP2D_NODO::importe_wad(WAD_LEVEL *Nivel_wad, long int pos)
{
    if ( !Nivel_wad->Nodes) {
        fprintf(stderr, "ERROR FATAL: No se tiene una estructura BSP!\n");
        fflush(stderr);
        return;
    }

    if ( pos > (Nivel_wad->Nodes->size)/28 ) {
        fprintf(stderr, "Warning: El nodo %ld esta fuera de rango!\n", pos);
        fflush(stderr);
        return;
    }

    fseek(Nivel_wad->wad_fd, Nivel_wad->Nodes->offset + pos*28, SEEK_SET);

    WORD temp;

    lea_WORD_BE(&linea_x, Nivel_wad->wad_fd);
    CORREGIR(linea_x);
    lea_WORD_BE(&linea_y, Nivel_wad->wad_fd);
    CORREGIR(linea_y);

    lea_WORD_BE(&linea_dx, Nivel_wad->wad_fd);
    lea_WORD_BE(&linea_dy, Nivel_wad->wad_fd);
    if ( linea_dx > 32768 ) linea_dx -= 65536;  // OJO: Machete horroroso!
    if ( linea_dy > 32768 ) linea_dy -= 65536;

    lea_WORD_BE(&max_der.y, Nivel_wad->wad_fd);
    CORREGIR(max_der.y);
    lea_WORD_BE(&min_der.y, Nivel_wad->wad_fd);
    CORREGIR(min_der.y);
    lea_WORD_BE(&min_der.x, Nivel_wad->wad_fd);
    CORREGIR(min_der.x);
    lea_WORD_BE(&max_der.x, Nivel_wad->wad_fd);
    CORREGIR(max_der.x);

    lea_WORD_BE(&max_izq.y, Nivel_wad->wad_fd);
    CORREGIR(max_izq.y);
    lea_WORD_BE(&min_izq.y, Nivel_wad->wad_fd);
    CORREGIR(min_izq.y);
    lea_WORD_BE(&min_izq.x, Nivel_wad->wad_fd);
    CORREGIR(min_izq.x);
    lea_WORD_BE(&max_izq.x, Nivel_wad->wad_fd);
    CORREGIR(max_izq.x);

    // OJO: Aqui se hace un alegre acto de fe y no se verifican limites en los
    // indices de hojas y/o nodos.
    lea_WORD_BE(&temp, Nivel_wad->wad_fd);
    if ( !(temp & BIT_15) ) {
        temp = (WORD)(temp & ~(BIT_15));
        Der = &(Padre->Nodos[temp]);
    }
    else {
        temp = (WORD)(temp & ~(BIT_15));
        Der = &(Padre->Hojas[temp]);
    }

    lea_WORD_BE(&temp, Nivel_wad->wad_fd);
    if ( !(temp & BIT_15) ) {
        temp = (WORD)(temp & ~(BIT_15));
        Izq = &(Padre->Nodos[temp]);
    }
    else {
        temp = (WORD)(temp & ~(BIT_15));
        Izq = &(Padre->Hojas[temp]);
    }
    fflush(stdout);
}

/*---------------------------------------------------------------------------
OJO: Esta macro debe ser vista como si se tratase de un metodo de la clase
     _BSP2D_NODO.  Implementa un servicio privado para los metodos de
     visualizacion del _BSP2D_NODO.
*/
#define PINTADO_NODO(metodo)                                                 \
    posicion_camara.z = 0;                                                   \
    orientacion_camara.z = 0;        /* OJO: Machete.                     */ \
    orientacion_camara.normalizar(); /* OJO: Esto asume que el vector esta*/ \
                                     /*      en el plano z = 0            */ \
                                                                             \
    VECTOR orientacion_cortante(linea_dx, linea_dy, 0);                      \
    VECTOR posicion_cortante(A_METROS(linea_x), A_METROS(linea_y), 0);       \
    VECTOR orientacion_camara_i;                                             \
    VECTOR orientacion_camara_d;                                             \
    orientacion_cortante.normalizar();                                       \
                                                                             \
    VECTOR normal;                                                           \
    MATRIZ_4x4 R;                                                            \
    double criterio;                                                         \
                                                                             \
    R.rotacion_eje(DEG2RAD(-30), 0, 0, 1);                                   \
    orientacion_camara_d = R*orientacion_camara;                             \
    R.rotacion_eje(DEG2RAD(30), 0, 0, 1);                                    \
    orientacion_camara_i = R*orientacion_camara;                             \
                                                                             \
    if (                                                                     \
        se_intersectan(posicion_camara, orientacion_camara_i,                \
                       posicion_cortante, orientacion_cortante) ||           \
        se_intersectan(posicion_camara, orientacion_camara_d,                \
                       posicion_cortante, orientacion_cortante)              \
       ) {                                                                   \
        /*- Caso recursivo -----------------------------------------------*/ \
        if ( Der ) {                                                         \
            Der->metodo(posicion_camara, orientacion_camara, Calidad);       \
        }                                                                    \
        if ( Izq ) {                                                         \
            Izq->metodo(posicion_camara, orientacion_camara, Calidad);       \
        }                                                                    \
      }                                                                      \
      else {                                                                 \
        /*- Caso recursivo -----------------------------------------------*/ \
        R.rotacion_eje(DEG2RAD(90), 0, 0, 1);                                \
        normal = R*orientacion_cortante;                                     \
        criterio = normal.producto_punto(posicion_camara-posicion_cortante); \
                                                                             \
        if ( criterio < 0 && Der ) {                                         \
            Der->metodo(posicion_camara, orientacion_camara, Calidad);       \
        }                                                                    \
        if ( criterio > 0 && Izq ) {                                         \
            Izq->metodo(posicion_camara, orientacion_camara, Calidad);       \
        }                                                                    \
    }

#ifdef GL_ENABLED
void
_BSP2D_NODO::pintar_gl_2D(
    VECTOR posicion_camara, VECTOR orientacion_camara, CALIDAD_VISUAL *Calidad)
{
    //----------------------------------------------------------------------
    PINTADO_NODO(pintar_gl_2D);

    //- Caso trivial -------------------------------------------------------
#ifdef NONONO
    _BSP2D_VERTICEi v;

    // Minmax del hijo izquierdo
    if ( Izq && Izq->mi_tipo == 'n' ) {
        //glLineWidth(0.5f);
        glColor3f(0.7, 0, 0.7);

        glBegin(GL_LINE_LOOP);
        v.x = min_izq.x; v.y = min_izq.y;    PINTAR_VERTICE(v, 0);
        v.x = min_izq.x; v.y = max_izq.y;    PINTAR_VERTICE(v, 0);
        v.x = max_izq.x; v.y = max_izq.y;    PINTAR_VERTICE(v, 0);
        v.x = max_izq.x; v.y = min_izq.y;    PINTAR_VERTICE(v, 0);
        glEnd();
    }

    // Minmax del hijo derecho
    if ( Der && Der->mi_tipo == 'n' ) {
        //glLineWidth(0.5f);
        glColor3f(0, 0.7, 0.7);
        glBegin(GL_LINE_LOOP);
        v.x = min_der.x; v.y = min_der.y;    PINTAR_VERTICE(v, 0);
        v.x = min_der.x; v.y = max_der.y;    PINTAR_VERTICE(v, 0);
        v.x = max_der.x; v.y = max_der.y;    PINTAR_VERTICE(v, 0);
        v.x = max_der.x; v.y = min_der.y;    PINTAR_VERTICE(v, 0);
        glEnd();
    }

    // Recta de particion
    glShadeModel(GL_SMOOTH);
    //glLineWidth(2.0f);
    glBegin(GL_LINES);
        glColor3f(0, 1, 0);     v.x = linea_x;          v.y = linea_y;
        PINTAR_VERTICE(v, 0.05);

        glColor3f(0, 0.5, 0); v.x = linea_x+linea_dx; v.y = linea_y+linea_dy;
        PINTAR_VERTICE(v, 0.05);
    glEnd();
#endif
}

void
_BSP2D_NODO::pintar_gl_3D(
    VECTOR posicion_camara, VECTOR orientacion_camara, CALIDAD_VISUAL *Calidad)
{
    //----------------------------------------------------------------------
    PINTADO_NODO(pintar_gl_3D);
}
#endif // GL_ENABLED

double
_BSP2D_NODO::altura_cuadro(WORD xx, WORD yy)
{
    int x = xx, y = yy;

    // Caso recursivo
    if ( x>=min_izq.x && x<=max_izq.x && y>=min_izq.y && y<=max_izq.y ) {
        return Izq->altura_cuadro(x, y);
    }

    if ( x>=min_der.x && x<=max_der.x && y>=min_der.y && y<=max_der.y ) {
        return Der->altura_cuadro(x, y);
    }

    // Caso trivial: verificacion fallida de min-max (Notese otro final de la
    // recursion es una llamada al metodo HOJA::altura_cuadro)

    return 0;
}

//=*************************************************************************=
//= TERCARA SECCION: ENCAPSULAMIENTO DEL MODELO Y PRESTACION DE SERVICIOS   =
//=*************************************************************************=

//===========================================================================
//= Clase BSP_2D                                                            =
//=-------------------------------------------------------------------------=
//= Esta seccion esta divida en tres trozos:                                =
//=   - Servicios basicos                                                   =
//=   - Servicios de persistencia (metodo `importe_wadlevel`)               =
//=   - Servicios de visualizacion (metodos `pintar*` y sus subrutinas)     =
//===========================================================================

//= SERVICIOS BASICOS DE LA CLASE BSP_2D ====================================

BSP_2D::BSP_2D()
{
    //- Inicializaciones varias --------------------------------------------
    min.x = min.y = INT_MAX;
    max.x = max.y = INT_MIN;
    datos_wad = NULL;

    //- Estructura geometrica BREP nula ------------------------------------
    Vertices = NULL;    num_vertices = 0;
    Arcos = NULL;       num_arcos = 0;
    Segmentos = NULL;   num_segmentos = 0;
    Paredes = NULL;     num_paredes = 0;
    Sectores = NULL;    num_sectores = 0;

    //- Arbol de particion nulo --------------------------------------------
    Nodos = NULL;       num_nodos = 0;
    Hojas = NULL;       num_hojas = 0;
    Raiz = NULL;
}

BSP_2D::~BSP_2D()
{
    ;
}

void
BSP_2D::mover(_BSP2D_VERTICEi delta)
{
    long int i;

    min.x = min.y = INT_MAX;    max.x = max.y = INT_MIN;
    for ( i = 0; i < num_vertices; i++ ) {
        Vertices[i].x += delta.x;
        Vertices[i].y += delta.y;

        if ( Vertices[i].x > max.x ) max.x = Vertices[i].x;
        if ( Vertices[i].y > max.y ) max.y = Vertices[i].y;
        if ( Vertices[i].x < min.x ) min.x = Vertices[i].x;
        if ( Vertices[i].y < min.y ) min.y = Vertices[i].y;
    }

    //Raiz->mover(delta);
}

double
BSP_2D::altura(double x, double y)
{
    //WORD i = A_RECUADROS(x), j = A_RECUADROS(y);
    //return Raiz->altura_cuadro(i, j);

    long int i;
    double altura;
    for ( i = 0; i < num_sectores; i++ ) {
        if ( Sectores[i].altura(x, y, &altura) ) return altura;
    }
    return 0;
}

void
BSP_2D::anexar_textura(IMAGEN * /*img*/)
{
    fprintf(stderr, "<BSP_2D> OJO: `anexar_textura` no implementado!\n");
    fflush(stderr);
}

int
BSP_2D::clasificar_punto(VECTOR /*p*/)
{
    fprintf(stderr, "<BSP_2D> OJO: `clasificar_punto` no implementado!\n");
    fflush(stderr);

    return 0;
}

GEOMETRIA *
BSP_2D::crear_copia(void)
{
    fprintf(stderr, "<BSP_2D> OJO: `crear_copia` no implementado!\n");
    fflush(stderr);
    return NULL;
}

//= SERVICIOS DE PERSISTENCIA DE LA CLASE BSP_2D ============================

BOOLEAN
BSP_2D::importe_wadlevel(WAD_DATABASE *w, int id_nivel)
{
    WAD_LEVEL *Nivel_wad = w->niveles[id_nivel];
    unsigned long i;
    char cad[1000];

    datos_wad = w;

    //- Importe vertices ------------------------------------------------------
    CHEQUEO_WAD(Nivel_wad->Vertexes, "No hay vertices en el nivel WAD!");

    Vertices = new _BSP2D_VERTICEi[Nivel_wad->Vertexes->size / 4];
    sprintf(cad, "No se pueden crear %ld vertices.",
        Nivel_wad->Vertexes->size/4);
    CHEQUEO_WAD(Vertices, cad);

    num_vertices = Nivel_wad->Vertexes->size / 4;
    fseek(Nivel_wad->wad_fd, Nivel_wad->Vertexes->offset, SEEK_SET);

    for ( i = 0; i < (unsigned long)num_vertices; i++ ) {
        lea_WORD_BE(&Vertices[i].x, Nivel_wad->wad_fd);
        lea_WORD_BE(&Vertices[i].y, Nivel_wad->wad_fd);

        // OJO: Esta correccion es de dudosa procedencia empirica: Al parecer
        // en el archivo las unidades son enteros con signo (complemento a 2)
        // y no "WORD" (que son sin signo).
        CORREGIR(Vertices[i].x);    CORREGIR(Vertices[i].y);
        //

        if ( Vertices[i].x > max.x ) max.x = Vertices[i].x;
        if ( Vertices[i].y > max.y ) max.y = Vertices[i].y;
        if ( Vertices[i].x < min.x ) min.x = Vertices[i].x;
        if ( Vertices[i].y < min.y ) min.y = Vertices[i].y;
    }

    // OJO!
    //LA_vista->centro_x = (max.x + min.x) / 2;
    //LA_vista->centro_y = (max.y + min.y) / 2;


    // OJO: Sera mejor correr los vertices de tal manera que el nivel quede
    // "Centrado"?    
    _BSP2D_VERTICEi delta;

    delta.x = -(max.x - min.x)/2 - (min.x - 32768);
    delta.y = -(max.y - min.y)/2 - (min.y - 32768);
    mover(delta);

    //- Prepare las paredes ---------------------------------------------------
    Paredes = new _BSP2D_PARED[Nivel_wad->Sidedefs->size / 30];
    CHEQUEO_WAD(Paredes, "No se pueden crear las paredes (SIDEDEFS)!");
    num_paredes = Nivel_wad->Sidedefs->size / 30;

    for ( i = 0; i < (unsigned long)num_paredes; i++ ) {
        Paredes[i].importe_wad(this, Nivel_wad, i);
    }

    //- Importe arcos ---------------------------------------------------------
    Arcos = new _BSP2D_ARCO[Nivel_wad->Linedefs->size / 14];
    VERIFIQUE(Arcos, "ERROR: No se pueden crear %ld arcos.\n", 
              Nivel_wad->Linedefs->size / 14);
    num_arcos = Nivel_wad->Linedefs->size / 14;

    for ( i = 0; i < (unsigned long)num_arcos ; i++) {
        Arcos[i].importe_wad(this, Nivel_wad, i);
    }

    //- Prepare los segmentos  ------------------------------------------------
    Segmentos = new _BSP2D_SEGMENTOi[(Nivel_wad->Segs->size)/12];
    VERIFIQUE(Arcos, "ERROR: No se pueden crear %ld segmentos.\n", 
              Nivel_wad->Segs->size / 12);
    num_segmentos = (Nivel_wad->Segs->size)/12;

    for ( i = 0; i < (unsigned long)num_segmentos; i++ ) {
        Segmentos[i].importe_wad(this, Nivel_wad, i);
    }

    //- Prepare los sectores --------------------------------------------------
    Sectores = new _BSP2D_SECTOR[(Nivel_wad->Sectors->size)/26];
    VERIFIQUE(Sectores, "ERROR: No se pueden crear %ld sectores.\n", 
              Nivel_wad->Sectors->size / 26);
    num_sectores = (Nivel_wad->Sectors->size)/26;

    for ( i = 0; i < (unsigned long)num_sectores; i++ ) {
        Sectores[i].importe_wad(this, Nivel_wad, i);
    }

    //- Prepare las hojas del arbol BSP ---------------------------------------
    Hojas = new _BSP2D_HOJA[(Nivel_wad->Ssectors->size)/4];
    VERIFIQUE(Hojas, "ERROR: No se pueden crear %ld hojas (SSECTORS).\n", 
              Nivel_wad->Ssectors->size / 4);
    num_hojas = (Nivel_wad->Ssectors->size)/4;

    for ( i = 0; i < (unsigned long)num_hojas; i++ ) {
        Hojas[i].init(this);
        Hojas[i].importe_wad(Nivel_wad, i);
    }

    //- Construya la estructura BSP (!) ---------------------------------------
    Nodos = new _BSP2D_NODO[(Nivel_wad->Nodes->size)/28];
    VERIFIQUE(Hojas, "ERROR: No se pueden crear %ld hojas (SSECTORS).\n", 
              Nivel_wad->Nodes->size / 28);
    num_nodos = (Nivel_wad->Nodes->size)/28;

    for ( i = 0; i < (unsigned long)num_nodos; i++ ) {
        Nodos[i].init(this);
        Nodos[i].importe_wad(Nivel_wad, i);
    }
    Raiz = &Nodos[num_nodos - 1]; 

    //- Ejecute la etapa de preprocesamiento ----------------------------------
    for ( i = 0; i < (unsigned long)num_paredes; i++ ) {
        // Normales de las paredes
        Paredes[i].calcule_normal();
    }
    for ( i = 0; i < (unsigned long)num_sectores; i++ ) {
        // Triangularizacion de sectores
        Sectores[i].triangularize();
    }
    Raiz->mover(delta);               // Colocar la estructura cerca del origen
    datos_wad->localice_paleta(0);    // Prepare la paleta de colores
    paleta_para_texturas.importar_raw256(datos_wad->fd);
    paleta_para_texturas.aplique_gamma(1.5);

    return TRUE;
}

int
BSP_2D::deme_flat(char *nombre)
{
    int i;

    if ( strcmp(nombre, "-") == 0 ) return -1;

    // Busque el nombre de la textura a ver si ya estaba
    for ( i = 0; i < nombres_flats.tam(); i++ ) {
        if ( strcmp(nombre, nombres_flats[i]) == 0 ) {
            return i;
        }
    }

    // Esta es una textura nueva!
    char *nuevo_nombre;
    IMAGEN_PAL *nueva_imagen;

    // Busque esta textura en el WAD
    if ( !datos_wad->localice_flat_por_nombre(nombre) ) {
        printf("Warning: La imagen flat-\"%s\" no se encontro en el WAD!\n",
               nombre);
        return -2;
    }

    nuevo_nombre = new char[9];
    strcpy(nuevo_nombre, nombre);
    nombres_flats.anx(nuevo_nombre);

    nueva_imagen = new IMAGEN_PAL();
    nueva_imagen->importar_wadflat(datos_wad->fd);
    flats.anx(nueva_imagen);

    return nombres_flats.tam() - 1;
}

int
BSP_2D::deme_textura(char *nombre)
{
    int i;

    for ( i = 0; i < 8; i++ ) nombre[i] = (char)toupper(nombre[i]);

    if ( strcmp(nombre, "-") == 0 ) return -1;

    // Busque el nombre de la textura a ver si ya estaba
    for ( i = 0; i < nombres_sprites.tam(); i++ ) {
        if ( strcmp(nombre, nombres_sprites[i]) == 0 ) {
            return i;
        }
    }

    // Esta es una textura nueva!
    char *nuevo_nombre;
    IMAGEN_PAL *nueva_imagen, *bitmap_i;
    int x_tam, y_tam, num_trozos, *Arr_x, *Arr_y, *Arr_i;

    // Busque esta textura en el WAD
    if ( !datos_wad->localice_textura_por_nombre(nombre,
             &x_tam, &y_tam, &num_trozos, &Arr_x, &Arr_y, &Arr_i) ) {
        fprintf(stderr, "<BSP_2D> - Error: La textura \"%s\" es invalida!\n",
            nombre);
        fflush(stderr);
        return -1;
      }
      else {
        // Cree la textura final
        nueva_imagen = new IMAGEN_PAL();
        if ( !nueva_imagen || !nueva_imagen->init(x_tam, y_tam) ) {
            fprintf(stderr, "<BSP_2D> - Error fatal: mal de memoria!\n");
            fflush(stderr);
            return -1;
        }

        // Pegue a manera de retazos todos los trozos sobre la textura final
        for ( i = 0; i < num_trozos; i++ ) {
            bitmap_i = new IMAGEN_PAL();
            if ( !bitmap_i ) {
                fprintf(stderr, "<BSP_2D> - Error fatal: mal de memoria!\n");
                fflush(stderr);
                return -1;
            }

            if ( !datos_wad->localice_imagen_por_nombre(
                    datos_wad->tabla_pname[Arr_i[i]]) || 
                    !bitmap_i->importar_wadsprite(datos_wad->fd) ) {
                fprintf(stderr, "<BSP_2D> - Error fatal: mal de memoria!\n");
                fflush(stderr);
                return -1;
            }
            nueva_imagen->pegar_subimagen(bitmap_i, Arr_x[i], Arr_y[i]);
            delete bitmap_i;
            bitmap_i = NULL;
        }

        // Elimine estructuras temporales
        delete Arr_x;
        delete Arr_y;
        delete Arr_i;
    }

    // Inserte la textura en la lista de imagenes preprocesadas
    printf("."); fflush(stdout);
    nuevo_nombre = new char[9];
    strcpy(nuevo_nombre, nombre);
    nombres_sprites.anx(nuevo_nombre);
    sprites.anx(nueva_imagen);

    return nombres_sprites.tam() - 1;
}

//= SERVICIOS DE VISUALIZACION DE LA CLASE BSP_2D ===========================

#ifdef GL_ENABLED
void
BSP_2D::activar_calidad(CALIDAD_VISUAL *Calidad, MATERIAL *Material)
{
    if ( Calidad->calidad_caras == CVC_CONSTANTE ) {
        glDisable(GL_LIGHTING);
        glColor3f(0.9f, 0.9f, 0.9f);
      } 
      else {
        glEnable(GL_LIGHTING);
    }
    if ( Calidad->calidad_caras == CVC_SHADE ) {
        glShadeModel(GL_SMOOTH);
      }
      else {
        glShadeModel(GL_FLAT);
    }

    if ( Calidad->con_textura ) {
        paleta_para_texturas.activar_gl();
        glEnable(GL_TEXTURE_2D); 
      }
      else {
        glDisable(GL_TEXTURE_2D);
    }

    Material->activar_gl();
    PRIMITIVA_triangulos = GL_TRIANGLES;
    PRIMITIVA_cuadros = GL_QUADS;
}

void
BSP_2D::pintar_gl_3D_wireframe(CALIDAD_VISUAL *Calidad)
{
    long int i;

    for ( i = 0; i < num_sectores; i++ ) {
        Sectores[i].marcado = TRUE;
        Sectores[i].con_paredes = TRUE;
    }
    PRIMITIVA_triangulos = GL_LINE_LOOP;
    PRIMITIVA_cuadros = GL_LINE_LOOP;
    glDisable(GL_LIGHTING);
    glColor3f(1, 0, 0);
    pintar_gl_3D(Calidad);
}

void
BSP_2D::pintar_gl_3D(CALIDAD_VISUAL *Calidad)
{
    long int i;

    for ( i = 0; i < num_sectores; i++ ) Sectores[i].pintar_gl_3D(Calidad);

    // OJO: Si, en este momento el metodo esta cortico... pero tenga en
    //      cuenta que aqui se debera detectar cuando la camara este por
    //      fuera de un sector, y cambiar el algoritmo por uno que solo
    //      pintar (desde afuera) el cascaron de todo el modelo BSP... (!)
}

void
BSP_2D::pintar_gl(CALIDAD_VISUAL *Calidad, MATERIAL* Material, CAMARA * /*Camara*/)
{
    //- En el modo indiscriminado todos los sectores se pintan -------------
    long int i;
    for ( i = 0; i < num_sectores; i++ ) {
        Sectores[i].marcado = TRUE;
        Sectores[i].con_paredes = TRUE;
    }

    //- Pintado wireframe --------------------------------------------------
    if ( Calidad->con_bordes ) pintar_gl_3D_wireframe(Calidad);

    //- Pintado standard ---------------------------------------------------
    if ( Calidad->con_caras ) {
        activar_calidad(Calidad, Material);
        pintar_gl_3D(Calidad);
    }
}

void
BSP_2D::pintar_bsp(CALIDAD_VISUAL *Calidad, MATERIAL *Material, CAMARA *Camara)
{
    //- Pintado wireframe (no se usa el BSP) -------------------------------
    if ( Calidad->con_bordes ) pintar_gl_3D_wireframe(Calidad);

    //- Inicializacion para el recorrido en modo BSP -----------------------
    long int i;
    for ( i = 0; i < num_sectores; i++ ) {
        Sectores[i].marcado = FALSE;
        Sectores[i].con_paredes = FALSE;
    }

    //- Pintado usando la estructura BSP -----------------------------------
    if ( Calidad->con_caras ) activar_calidad(Calidad, Material);

    // Notese como se tiene en cuenta la camara!
    VECTOR orientacion_camara, ejex(1, 0, 0);
    MATRIZ_4x4 R;
    double pitch, yaw, roll;

    R.importar_quaternion(Camara->orientacion());
    R.exportar_angulos_euler(&yaw, &pitch, &roll);
    R.rotacion_eje(yaw, 0, 0, 1);
    orientacion_camara = R * ejex;

    // Recorra la estructura BSP... dentro de eso esta todo el truco!
    NUM_poligonos = 0;
    BOOLEAN pintar_plano = FALSE;  // OJO!

    if ( pintar_plano ) {
        glDisable(GL_LIGHTING);
        Raiz->pintar_gl_2D(Camara->posicion(), orientacion_camara, Calidad);
      }
      else{
        glEnable(GL_LIGHTING);
        Raiz->pintar_gl_3D(Camara->posicion(), orientacion_camara, Calidad);
        for ( i = 0; i < num_sectores; i++ ) Sectores[i].pintar_gl_3D(Calidad);
    }
    //printf("Pinto %d poligonos!\n", NUM_poligonos);  fflush(stdout);
}
#endif // GL_ENABLED

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

void
BSP_2D::pintar_povray(FILE *fd)
{
    // OJO: Esto no se ha hecho!
    fprintf(fd,
        "sphere {\n"
        "    <0, 0, 0>, 0.3\n"
    );
}

//===========================================================================
//= Fin de la accion!                                                       =
//===========================================================================

---

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.