rayo.C

Ir a la documentación de este archivo.

//===========================================================================
//= rayo.cc                                                   Julio de 1999 =
//=-------------------------------------------------------------------------=
//= Definicion de la clase RAYO.                                            =
//=-------------------------------------------------------------------------=
//= 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 "jed_defs.h"
#include "toolkits/entorno/rayo.h"
#include "toolkits/util/parsero.h"
#include "matriz4.h"

#include <stdlib.h>
#include <string.h>

//===========================================================================
//= VARIABLES GLOBALES Y MACROS                                             =
//===========================================================================

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

//===========================================================================
//= CLASE RAYO                                                              =
//===========================================================================

#ifdef GL_ENABLED
void
RAYO::pintar_gl(void)
{
    glDisable(GL_LIGHTING);
    //glPointSize(4);
    glColor3f(1, 0, 0);
    glBegin(GL_POINTS);
        glVertex3d(origen.x, origen.y, origen.z);
    glEnd();

    glColor3d(0, 1, 1);
    glBegin(GL_LINES);
        glVertex3d(origen.x, origen.y, origen.z);
        glVertex3d(origen.x + direccion.x,
                   origen.y + direccion.y,
                   origen.z + direccion.z);
    glEnd();
}
#endif

BOOLEAN
RAYO::procesar_teclado(EVENTO_GUI *e)
{
    double theta, phi;

#define INICIO_ANGULAR() \
    phi = asin(direccion.z); \
    if ( fabs(direccion.x) < EPSILON && \
         fabs(direccion.y) < EPSILON ) direccion.x = 1; \
    direccion.z = 0; \
    direccion.normalizar(); \
    if ( direccion.y > 0 ) theta=acos(direccion.x); \
    else theta = -acos(direccion.x); 

#define FIN_ANGULAR() \
    direccion.x = cos(phi) * cos(theta); \
    direccion.y = cos(phi) * sin(theta); \
    direccion.z = sin(phi); \
    direccion.normalizar(); \
    break;

    switch( e->key_code ) {
  case JK_k: INICIO_ANGULAR();
    theta -= DEG2RAD(5);
    while ( theta < DEG2RAD(0) ) theta += DEG2RAD(360);
    FIN_ANGULAR();
  case JK_h:  INICIO_ANGULAR();
    theta += DEG2RAD(5);
    while ( theta >= DEG2RAD(360) ) theta -= DEG2RAD(360);
    FIN_ANGULAR();
  case JK_j:    INICIO_ANGULAR();
    phi -= DEG2RAD(5);
    if ( phi < DEG2RAD(-90) ) phi = DEG2RAD(-90);
    FIN_ANGULAR();
  case JK_u:  INICIO_ANGULAR();
    phi += DEG2RAD(5);
    if ( phi > DEG2RAD(90) ) phi = DEG2RAD(90);
    FIN_ANGULAR();
  case JK_q:        origen.x -= 0.1; break;
  case JK_Q:        origen.x += 0.1; break;
  case JK_w:        origen.y -= 0.1; break;
  case JK_W:        origen.y += 0.1; break;
  case JK_e:        origen.z -= 0.1; break;
  case JK_E:        origen.z += 0.1; break;
  default: return FALSE;
    }
    return TRUE;
}

BOOLEAN
RAYO::leer(TOKENIZADOR *Sabiondo)
{
    char cad[1000];
    int tipo_token = TK_DESCONOCIDO, pos;
    MATRIZ_4x4 R;
    double yaw, pitch;
    VECTOR eje_x(1, 0, 0);

    //- Ejecute el parser especifico de la COSA_RIGIDA -----------------
    pos = 2;
    while ( tipo_token != TK_CERRAR) {
        tipo_token = Sabiondo->siguiente_token(cad);
        switch ( pos ) {
          /*
            case 1:
              ESPERO(TK_CADENA, "una cadena");
              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, "origen") == 0 ) {
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_VECTOR_INICIO, "el inicio de un VECTOR");
                  origen.x = atof(&cad[1]);
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_NUMERO, "un numero (dato 2 de un VECTOR)");
                  origen.y = atof(cad);
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_VECTOR_FIN, "el final de un VECTOR");
                  cad[strlen(cad) - 1] = '\0';
                  origen.z = atof(cad);
                }
                else if ( strcmp(cad, "direccion") == 0 ) {
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_VECTOR_INICIO, "el inicio de un VECTOR");
                  direccion.x = atof(&(cad[1]));
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_NUMERO, "un numero (dato 2 de un VECTOR)");
                  direccion.y = atof(cad);
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_VECTOR_FIN, "el final de un VECTOR");
                  cad[strlen(cad) - 1] = '\0';
                  direccion.z = atof(cad);
                  direccion.normalizar();
                }
                else if ( strcmp(cad, "direccion_angular") == 0 ) {
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_VECTOR_INICIO, "el inicio de un VECTOR");
                  yaw = DEG2RAD(atof(&(cad[1])));
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_VECTOR_FIN, "el final de un VECTOR");
                  cad[strlen(cad) - 1] = '\0';
                  pitch = DEG2RAD(atof(cad));
                  R.rotacion_angulos_euler(yaw, pitch, 0);
                  direccion = R * eje_x;
                }
              ;
              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.