visor_g.C

Ir a la documentación de este archivo.

//===========================================================================
//= visor_g.h                                                 Julio de 1998 =
//=-------------------------------------------------------------------------=
//= Definicion de clase VISOR_GEOMETRIA                                     =
//=-------------------------------------------------------------------------=
//= 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 <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "framework/visual/visor_g.h"
#include "toolkits/geom/mesh.h"
#include "toolkits/media/jed_img.h"
#include "matriz4.h"
#include "lista.cc"

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

#define INICIO_EULER() \
    R.importar_quaternion(orientacion); \
    R.exportar_angulos_euler(&yaw, &pitch, &roll);

#define FIN_EULER() \
    R.rotacion_angulos_euler(yaw, pitch, roll); \
    orientacion = R.exportar_quaternion();

#define ESPERO(tipo, msg) \
    if ( tipo_token != (tipo) ) { \
        fprintf(stderr, "<VISOR_GEOMETRIA> " \
          "ERROR: Esperaba %s y recibi [%s].\n", \
          (msg), cad); fflush(stderr);  return FALSE; \
    }

#define VERIFICAR(c) \
    if ( !(c) ) {\
        fprintf(stderr, \
            "<VISOR_GEOMETRIA> " \
            "ERROR: No se pudo crear un objeto dinamico!\n");\
        fflush(stderr);\
        exit(1);\
    }

//===========================================================================
//= CLASE VISOR_GEOMETRIA                                                   =
//===========================================================================

VISOR_GEOMETRIA::VISOR_GEOMETRIA() : VISOR()
{
    controlando_camara = TRUE;
    Geometria = NULL;
    mostrar_ejes = FALSE;
    modo_stereo = STEREO_NULL;
    init();
}

VISOR_GEOMETRIA::VISOR_GEOMETRIA(GEOMETRIA *g) : VISOR()
{
    controlando_camara = TRUE;
    Geometria = g;
    mostrar_ejes = FALSE;
    modo_stereo = STEREO_NULL;
    init();
}

VISOR_GEOMETRIA::~VISOR_GEOMETRIA()
{
    if ( _nombre_cosa ) delete _nombre_cosa;

    // OJO: La `Geometria` es responsabilidad de quien usa este visor, y aqui
    //      NO se borra!
    delete Material;
}

void
VISOR_GEOMETRIA::init(void)
{

    _nombre_cosa = NULL;
    mostrar_grilla = FALSE;

    Material = new MATERIAL;

    // Normalmente se tiene una camara mirando hacia el origen...
    //VECTOR p(2.5, -2.5, 2);
    //VECTOR p(1, -2.5, 2);
    VECTOR p(1.5, -2, 4.5);
    MATRIZ_4x4 R;

    camara.set_posicion(p);
    //R.rotacion_angulos_euler(DEG2RAD(135), DEG2RAD(-30), 0);
    //R.rotacion_angulos_euler(DEG2RAD(90), DEG2RAD(-45), 0);
    R.rotacion_angulos_euler(DEG2RAD(120), DEG2RAD(-50), 0);
    camara.set_orientacion(R.exportar_quaternion());

    // y la geometria no esta rotada
    R.identidad();
    orientacion = R.exportar_quaternion();

    luz1.set_id(0);
    luz2.set_id(1);
    _x_tam = 320;
    _y_tam = 200;
}

CAMARA *
VISOR_GEOMETRIA::get_camara(void)
{
    return &camara;
}

void
VISOR_GEOMETRIA::set_geometria(GEOMETRIA *g)
{
    Geometria = g;
}

char *
VISOR_GEOMETRIA::nombre_cosa(void)
{
    return _nombre_cosa;
}

#ifdef GL_ENABLED
void
VISOR_GEOMETRIA::pintar_nucleo_gl(void)
{
    //- Cuadrar modelo de iluminacion ---------------------------------------
    static VECTOR lp1(25, 25, 50);
    static VECTOR lp2(-25, -25, -50);

    glEnable(GL_LIGHTING);
    luz1.set_posicion(lp1);
    luz1.activar_gl();
    luz2.set_posicion(lp2);
    luz2.activar_gl();

    // El material por dentro (por si acaso) es rojo mate
    // OJO: Notese que el material por dentro esta especificado en MATERIAL
    static GLfloat back_mat_shininess[] = {1.0f}; // puede ir de 1 a 128
    static GLfloat back_mat_specular[] = {0.1f, 0.1f, 0.1f, 1.0f};
    static GLfloat back_mat_diffuse[] = {0.9f, 0, 0, 1.0f};

    glMaterialfv(GL_BACK, GL_SHININESS, back_mat_shininess);
    glMaterialfv(GL_BACK, GL_SPECULAR, back_mat_specular);
    glMaterialfv(GL_BACK, GL_DIFFUSE, back_mat_diffuse);

    //- Pintar geometria ----------------------------------------------------
    MATRIZ_4x4 R;

    glEnable(GL_DEPTH_TEST);
    glClear(GL_DEPTH_BUFFER_BIT);
    if ( Geometria ) {
        glLoadIdentity();
        R.importar_quaternion(orientacion);
        R.cargar_gl();        
        Geometria->pintar_gl(&calidad, Material, &camara);
    }

    //- Pintar ejes ---------------------------------------------------------
    MATERIAL m;
    COLOR c;
    VECTOR v_o(0, 0, 0), v_i(1, 0, 0), v_j(0, 1, 0), v_k(0, 0, 1);
    CALIDAD_VISUAL ql;

    ql.activar_caras_gl(c, &m);

    if ( mostrar_ejes ) {
        c.r = 1;        c.g = 0;        c.b = 0;
        m.set_difusa(c);        Material->activar_gl();
        PINTAR_VECTOR_GL(v_o, v_i, 0.025, 0.3, 0.05);

        c.r = 0;        c.g = 1;        c.b = 0;
        m.set_difusa(c);        Material->activar_gl();
        PINTAR_VECTOR_GL(v_o, v_j, 0.025, 0.3, 0.05);

        c.r = 0;        c.g = 0;        c.b = 1;
        m.set_difusa(c);        Material->activar_gl();
        PINTAR_VECTOR_GL(v_o, v_k, 0.025, 0.3, 0.05);
    }

    //- Pintar Grilla -------------------------------------------------------
    double x_tam = 1, y_tam = 1, z_tam = 1, delta = 0.1;
    VECTOR p;

    if ( mostrar_grilla ) { 
        glLoadIdentity();
        glEnable(GL_DEPTH_TEST);
        glDisable(GL_LIGHTING);
        glShadeModel(GL_FLAT);
        glDisable(GL_TEXTURE_2D);
        glColor3f(1, 1, 1);

        glBegin(GL_POINTS);
        for ( p.x = -x_tam; p.x < x_tam; p.x += delta ) {
            for ( p.y = -y_tam; p.y < y_tam; p.y += delta ) {
                for ( p.z = -z_tam; p.z < z_tam; p.z += delta ) {
                    if ( Geometria->clasificar_punto(p) >= 0 ) {
                        glVertex3f((float)p.x, (float)p.y, (float)p.z);
                        //glLoadIdentity();
                        //glTranslatef(p.x, p.y, p.z);
                        //pintar_cubo(delta/2);
                    }
                }
            }
        }
        glEnd();
    }
}

void
VISOR_GEOMETRIA::pintar_gl(void)
{
    IMAGEN_RGB izq, der, sum;

    //- Configurar un entorno virtual ---------------------------------------
    if ( modo_stereo == STEREO_NULL ) {
        glColor3f(0.5f, 0.5f, 0.7f);
        PINTAR_FONDO_VISOR();
        camara.activar_gl();
        pintar_nucleo_gl();
      }
      else {
        // Genere la primera imagen del par stereo (Ojo izquierdo)
        glColor3f(0.5f, 0.5f, 0.7f);    PINTAR_FONDO_VISOR();
        camara.activar_gl(1);
        pintar_nucleo_gl();
        izq.importar_gl(0, 0, _x_tam, _y_tam);

        // Genere la segunda imagen del par stereo (Ojo derecho)
        glColor3f(0.5f, 0.5f, 0.7f);    PINTAR_FONDO_VISOR();
        camara.activar_gl(2);
        pintar_nucleo_gl();
        der.importar_gl(0, 0, _x_tam, _y_tam);

        // Calcule la combinacion stereo
        sum.combinar_stereo(&izq, &der, modo_stereo);
        glColor3f(0.5f, 0.5f, 0.7f);    PINTAR_FONDO_VISOR();
        sum.pintar_gl();
    }

    //----------------------------------------------------------------------
    pintar_visores_subordinados_gl(&camara);
}
#endif // GL_ENABLED

int
VISOR_GEOMETRIA::procesar_teclado(EVENTO_GUI *e)
{
    switch( e->key_code ) {
      case JK_9:
        if ( controlando_camara ) controlando_camara = FALSE;
        else controlando_camara = TRUE;
        break;
      case JK_e:
        mostrar_ejes = !mostrar_ejes;
        break;
      case JK_E:
        modo_stereo++;
        if ( modo_stereo == STEREO_END ) modo_stereo = STEREO_NULL;
        break;
      case JK_g:
        if ( mostrar_grilla ) mostrar_grilla = 0;
        else mostrar_grilla = 1;
        break;
      default:
        return calidad.procesar_teclado(e) || camara.procesar_teclado(e);
    }
    return 1;
}

int
VISOR_GEOMETRIA::procesar_mouse(EVENTO_GUI *e)
{
    //if ( e->mouse_button_mask ) printf("%d", e->mouse_button_mask);
    //else printf(".");
    //fflush(stdout);

    if ( controlando_camara ) return camara.procesar_mouse(e);

    MATRIZ_4x4 R;
    double yaw, pitch, roll;

    if ( e->mouse_button_mask & 0x01 ) {
        // Rotacion
        INICIO_EULER();
        yaw += DEG2RAD(e->mouse_delta_x) * 2;
        pitch -= DEG2RAD(e->mouse_delta_y) * 2;
        FIN_EULER();
        return 1;
    }

    if ( e->mouse_button_mask & 0x02 ) {
        // Rotacion
        INICIO_EULER();
        roll += DEG2RAD(e->mouse_delta_y) * 2;
        FIN_EULER();
        return 1;
    }
    return 0;
}

void
VISOR_GEOMETRIA::procesar_resize(int /*x*/, int /*y*/,
                                 int x_tam, int y_tam)
{
    camara.procesar_resize(x_tam, y_tam);
    _x_tam = x_tam;
    _y_tam = y_tam;
}

//= SERVICIOS DE PERSISTENCIA ===============================================

BOOLEAN
VISOR_GEOMETRIA::leer(TOKENIZADOR *Sabiondo)
{
    char cad[1000];
    int tipo_token = TK_DESCONOCIDO, pos;

    //- Ejecute el parser especifico de la COSA_RIGIDA -----------------
    pos = 1;
    while ( tipo_token != TK_CERRAR) {
        tipo_token = Sabiondo->siguiente_token(cad);
        switch ( pos ) {
            case 1:
              ESPERO(TK_CADENA, "una cadena con un nombre de un VISOR");
              if ( strlen(cad) > MAX_CAD-1 ) cad[MAX_CAD-1] = '\0'; 
              des_comille(cad);
              //set_nombre(cad);
              pos++;
              break;
            case 2:  ESPERO(TK_ABRIR, "\"{\"");  pos++; break;
            default:
              if ( tipo_token == TK_CERRAR ) break;
              ESPERO(TK_IDENTIFICADOR, "un identificador (3)");
              if ( strcmp(cad, "objetivo") == 0 ) {
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_CADENA, "una cadena con el nombre de una COSA");
                  des_comille(cad);
                  _nombre_cosa = new char [strlen(cad) + 1];
                  VERIFICAR(_nombre_cosa);
                  strcpy(_nombre_cosa, cad);
                }
                else if ( !leer_visor_subordinado(Sabiondo, cad) ) {
                    return FALSE;
                }
              ;
              break;
        }
    }

    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.