visor_cv.C

Ir a la documentación de este archivo.

//===========================================================================
//= visor_g.cc                                               Agosto de 1998 =
//=-------------------------------------------------------------------------=
//= Definicion de clase VISOR_CAMPO_VECTORIAL                               =
//=-------------------------------------------------------------------------=
//= 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 "framework/visual/visor_cv.h"
#include "toolkits/geom/geometria.h"
#include "matriz4.h"
#include "lista.cc"

#include "toolkits/media/jed_img.h"

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

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

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

//===========================================================================
//= CLASE VISOR_CAMPO_VECTORIAL                                             =
//===========================================================================

VISOR_CAMPO_VECTORIAL::VISOR_CAMPO_VECTORIAL(CAMPO_VECTORIAL *c)
{
    Campo = c;
    init();
}

VISOR_CAMPO_VECTORIAL::VISOR_CAMPO_VECTORIAL()
{
    Campo = NULL;
    init();
}

VISOR_CAMPO_VECTORIAL::~VISOR_CAMPO_VECTORIAL()
{
    // OJO: El `campo` es responsabilidad de quien usa este visor, y aqui
    //      NO se borra!
    delete Material;
}

void
VISOR_CAMPO_VECTORIAL::init(void)
{
    _nombre_campo = NULL;

    // Mostrar el plano (z = 0)
    min.x = -5;  min.y = -5;  min.z = 0;
    max.x = 5;  max.y = 5;  max.z = 0;
    offset_plano = 0;
    luz.set_id(0);

    // Normalmente se tiene una camara mirando hacia el origen...
    VECTOR p(2.5, 0.5, 0.5);
    MATRIZ_4x4 R;

    camara.set_posicion(p);
    R.rotacion_angulos_euler(DEG2RAD(175), DEG2RAD(-25), 0);
    camara.set_orientacion(R.exportar_quaternion());

    // Las flechas son verde pastel   :-)
    COLOR col(0.5f, 0.7f, 0.5f);

    Material = new MATERIAL;
    Material->set_difusa(col);
}

char *
VISOR_CAMPO_VECTORIAL::nombre_campo(void)
{
    return _nombre_campo;
}

void
VISOR_CAMPO_VECTORIAL::set_campo(CAMPO_VECTORIAL *c)
{
    Campo = c;
}

#ifdef GL_ENABLED
void
VISOR_CAMPO_VECTORIAL::pintar_gl(void)
{
    //- Configurar un entorno virtual ---------------------------------------
    glColor3f(0.5f, 0.5f, 0.5f);
    PINTAR_FONDO_VISOR();
    camara.activar_gl();
    glCullFace(GL_BACK);
    glEnable(GL_CULL_FACE);
    glEnable(GL_DEPTH_TEST);
    glClear(GL_DEPTH_BUFFER_BIT);

    //- Cuadrar modelo de iluminacion ---------------------------------------
    static VECTOR lp(90, 90, 150);

    glEnable(GL_LIGHTING);
    luz.set_posicion(lp);
    luz.activar_gl();
    Material->activar_gl();
    glShadeModel(GL_SMOOTH);
    glDisable(GL_TEXTURE_2D);

    //- Pintar las lineas de campo ------------------------------------------
    VECTOR p, deltav;
    double delta = 2;

    for ( p.x = min.x; p.x <= max.x; p.x += delta ) {
        for ( p.y = min.y; p.y <= max.y; p.y += delta ) {
            for ( p.z = min.z; p.z <= max.z; p.z += delta ) {
                deltav = Campo->valor(p);
                deltav = deltav * 0.1;
                PINTAR_VECTOR_GL(p, p + deltav, 0.03, 0.3, 0.1);
            }
        }
    }

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

int
VISOR_CAMPO_VECTORIAL::procesar_teclado(EVENTO_GUI *e)
{
    static int modo = 1;

    switch( e->key_code ) {
      case JK_1: // Mostrar el plano (z = offset_plano)
        //printf("<VISOR_CAMPO_VECTORIAL>: Mostrando el plano z = %.2f.\n",
        //    offset_plano);
        //fflush(stdout);
        modo = 1;
        break;
      case JK_2: // Mostrar el plano (x = offset_plano)
        //printf("<VISOR_CAMPO_VECTORIAL>: Mostrando el plano x = %.2f.\n",
        //    offset_plano);
        //fflush(stdout);
        modo = 2;
        break;
      case JK_3: // Mostrar el plano (y = offset_plano)
        //printf("<VISOR_CAMPO_VECTORIAL>: Mostrando el plano y = %.2f.\n",
        //    offset_plano);
        //fflush(stdout);
        modo = 3;
        break;
      case JK_4: // Mostrar el volumen
        //printf("<VISOR_CAMPO_VECTORIAL>: Mostrando el volumen completo\n");
        //fflush(stdout);
        modo = 0;
        break;
      case JK_O:
        offset_plano += 1.0;
        //printf("<VISOR_CAMPO_VECTORIAL>: offset = %.2f\n", offset_plano);
        //fflush(stdout);
        break;
      case JK_o:
        offset_plano -= 1.0;
        //printf("<VISOR_CAMPO_VECTORIAL>: offset = %.2f\n", offset_plano);
        //fflush(stdout);
        break;
      default:
        return calidad.procesar_teclado(e) || camara.procesar_teclado(e);
    }
    min.x = -5;  min.y = -5;  min.z = -5;
    max.x = 5;  max.y = 5;  max.z = 5;
    switch ( modo ) {
      case 1: min.z = max.z = offset_plano; break;
      case 2: min.x = max.x = offset_plano; break;
      case 3: min.y = max.y = offset_plano; break;
      default: break;
    }
    return 1;
}

void
VISOR_CAMPO_VECTORIAL::procesar_resize(int /*x*/, int /*y*/,
                                       int x_tam, int y_tam)
{
    camara.procesar_resize(x_tam, y_tam);
}

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

BOOLEAN
VISOR_CAMPO_VECTORIAL::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_campo = new char [strlen(cad) + 1];
                  VERIFICAR(_nombre_campo);
                  strcpy(_nombre_campo, 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.