cosa.C

Ir a la documentación de este archivo.

//===========================================================================
//= cosa.h                                                    Julio de 1998 =
//=-------------------------------------------------------------------------=
//= Definiciones de la clase COSA                                           =
//=-------------------------------------------------------------------------=
//= 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_gl.h"
#include "lista.cc"
#include "core/cosas/cosa.h"
#include "toolkits/media/jed_img.h"
#include "toolkits/geom/mesh.h"
#include "toolkits/util/3dsload.h"
#include "matriz4.h"

#include "core/cosas/espacio.h"

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

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

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

//===========================================================================
//= CLASE COSA                                                              =
//===========================================================================

COSA::COSA()
{
    //- Configuraciones por defecto para una COSA ---------------------------
    _masa = 1.0f;          // 1Km
    _ke = 0.7f;            // Coeficiente de restitucion (elasticidad en 
                           // colision)
    _posicion.x = 0;       // Localizada en el origen
    _posicion.y = 0;
    _posicion.z = 0;
    _velocidad.x = 0;      // Quietecita
    _velocidad.y = 0;
    _velocidad.z = 0;
    _estoy_fijo = FALSE;   // Dinamica
    Padre = NULL;
    _nombre_padre = NULL;
    _tipo_de_cosa = CC_DESCONOCIDA;

    //- Material por defecto ------------------------------------------------
    if ( LOS_materiales.tam() < 1 ) {
        Material = new MATERIAL;
        if ( !Material ) { exit(1); }
        LOS_materiales.anx(Material);
    }
    Material = LOS_materiales[0];
    _color = Material->difusa();
}

COSA::~COSA()
{
    ;
}

int COSA::tipo_de_cosa(void) { return _tipo_de_cosa; }
BOOLEAN COSA::estoy_fijo(void) { return _estoy_fijo; }
COLOR COSA::color(void) { return _color; }
MATERIAL * COSA::material(void) { return Material; }

double
COSA::altura(VECTOR p)
{
    if ( _tipo_de_cosa == CC_ESPACIO_ABIERTO ) {
        return ((ESPACIO_ABIERTO*)this)->altura_espacio(p);
    }
    return 0;
}

VECTOR
COSA::posicion(void)
{
    return _posicion;
}

VECTOR
COSA::posicion_absoluta(VECTOR /*p*/)
{
    // MUCHO OJO! No se ha implementado! Debe utilizar la _orientacion, la
    // _posicion y la transformacion geometrica del padre si lo hay!...
    // Se espera que este metodo sea sobrecargado en las clases hijas...

    return _posicion;  // Solo es valido para MASA_PUNTUAL, y podria cambiarse
                       // por _posicion + p...
}

QUATERNION
COSA::orientacion_absoluta(void)
{
    QUATERNION resultado;

    if ( Padre ) {
        resultado = Padre->orientacion_absoluta() * resultado;
    }
    resultado.normalizar();
    return resultado;
}

static VECTOR TMP_vector;
static double TMP_double;

BOOLEAN
COSA::consultar_variable(const char *nombre_variable, int &tipo, void **ref)
{
    VECTOR centro_de_masa(0, 0, 0);

    if ( strcmp(nombre_variable, "masa") == 0 ) {
        tipo = T_FLOAT;    (*ref) = &_masa;    return TRUE;
      }

//OJO: ESTO ES PARA PROBLEMAS! COMO ASI QUE FLOAT O DOUBLE?
      else if ( strcmp(nombre_variable, "x") == 0 ) {
        tipo = T_FLOAT;    (*ref) = &_posicion.x;    return TRUE;
      }
      else if ( strcmp(nombre_variable, "y") == 0 ) {
        tipo = T_FLOAT;    (*ref) = &_posicion.y;    return TRUE;
      }
      else if ( strcmp(nombre_variable, "z") == 0 ) {
        tipo = T_FLOAT;    (*ref) = &_posicion.z;    return TRUE;
      }
      else if ( strcmp(nombre_variable, "altura") == 0 ) {
        tipo = T_FLOAT;
        TMP_double = 0;
        if ( Padre ) {
            TMP_double = Padre->altura(_posicion);
        }
        (*ref) = &TMP_double;
        return TRUE;
      }
      else if ( strcmp(nombre_variable, "posicion") == 0 ) {
        TMP_vector = posicion_absoluta(centro_de_masa);
        tipo = T_VECTOR;    (*ref) = &TMP_vector;    return TRUE;
      }
      else if ( strcmp(nombre_variable, "velocidad") == 0 ) {
        tipo = T_VECTOR;    (*ref) = &_velocidad;    return TRUE;
      }
    ;
    return FALSE;
}

BOOLEAN
COSA::actualizar_variable(const char *nombre_variable, int tipo, void *ref)
{
    //VECTOR centro_de_masa(0, 0, 0);
#ifdef NONONO
    if ( strcmp(nombre_variable, "masa") == 0 ) {
        tipo = T_FLOAT;    (*ref) = &_masa;    return TRUE;
      }

//OJO: ESTO ES PARA PROBLEMAS! COMO ASI QUE FLOAT O DOUBLE?
      else 
      else if ( strcmp(nombre_variable, "posicion") == 0 ) {
        TMP_vector = posicion_absoluta(centro_de_masa);
        tipo = T_VECTOR;    (*ref) = &TMP_vector;    return TRUE;
      }
      else
#endif

      if ( strcmp(nombre_variable, "velocidad") == 0 && tipo == T_VECTOR ) {
          set_velocidad_absoluta( *((VECTOR*)ref) );
          return TRUE;
      }
      else if ( strcmp(nombre_variable, "posicion")==0 && tipo == T_VECTOR ) {
          _posicion = ( *((VECTOR*)ref) );
          return TRUE;
      }
      else if ( strcmp(nombre_variable, "x") == 0 && tipo == T_FLOAT ) {
          _posicion.x = ( *((double*)ref) ); 
          return TRUE;
      }
      else if ( strcmp(nombre_variable, "y") == 0 && tipo == T_FLOAT ) {
          _posicion.y = ( *((double*)ref) ); 
          return TRUE;
      }
      else if ( strcmp(nombre_variable, "z") == 0 && tipo == T_FLOAT ) {
          _posicion.z = ( *((double*)ref) ); 
          return TRUE;
      }
      else if ( strcmp(nombre_variable, "altura") == 0 && tipo == T_FLOAT ) {
        double altura_actual, altura_deseada;

        altura_deseada = ( *((double*)ref) );
        if ( Padre ) {
            altura_actual = Padre->altura(_posicion);
            _posicion.z += (altura_deseada - altura_actual);
          }
          else {
            _posicion.z = altura_deseada;
        }
        return TRUE;
      }
    ;
    return FALSE;
}

char *
COSA::nombre_padre(void) { 
    return _nombre_padre;
}

void
COSA::asociar_padre(COSA *p)
{
    Padre = p;
}

COSA *
COSA::crear_copia(void)
{
    return NULL;
}

BOOLEAN
COSA::resolver(LISTA <COSA *> * /*Cosas*/)
{
    return TRUE;
}

void
COSA::leer_material(char *nombre)
{
    int i;

    des_comille(nombre);
    for ( i = 0; i < LOS_materiales.tam(); i++ ) {
        if ( strcmp(nombre, LOS_materiales[i]->nombre()) == 0 ) {
            Material = LOS_materiales[i];
            return;
        }
    }
    fprintf(stderr, 
        "<COSA> Warning: no se encuentra el material \"%s\".\n"
        "Tomando el material por defecto.\n", nombre);
}

void
COSA::grabar_basico(FILE *fd)
{
    char n1[200];
    char n2[200];
    char n3[200];

    sprintf(n1, "%f", _posicion.x);    simplifique_real(n1);
    sprintf(n2, "%f", _posicion.y);    simplifique_real(n2);
    sprintf(n3, "%f", _posicion.z);    simplifique_real(n3);
    fprintf(fd, "    posicion <%s, %s, %s>, ", n1, n2, n3);

    sprintf(n1, "%f", _velocidad.x);    simplifique_real(n1);
    sprintf(n2, "%f", _velocidad.y);    simplifique_real(n2);
    sprintf(n3, "%f", _velocidad.z);    simplifique_real(n3);
    fprintf(fd, "velocidad <%s, %s, %s>\n", n1, n2, n3);

    sprintf(n1, "%f", _masa);    simplifique_real(n1);
    fprintf(fd, "    masa %s, ", n1);

    sprintf(n1, "%f", _ke);    simplifique_real(n1);
    fprintf(fd, "ke %s,\n", n1);
}

BOOLEAN
COSA::leer_basico(TOKENIZADOR *Sabiondo, char *cad, BOOLEAN *cmc)
{
    int tipo_token = TK_DESCONOCIDO;
    int i;

    if ( strcmp(cad, "posicion") == 0 ) {
      tipo_token = Sabiondo->siguiente_token(cad);
      ESPERO(TK_VECTOR_INICIO, "el inicio de un VECTOR");
      _posicion.x = atof(&cad[1]);
      tipo_token = Sabiondo->siguiente_token(cad);
      ESPERO(TK_NUMERO, "un numero (dato 2 de un VECTOR)");
      _posicion.y = atof(cad);
      tipo_token = Sabiondo->siguiente_token(cad);
      ESPERO(TK_VECTOR_FIN, "el final de un VECTOR");
      cad[strlen(cad) - 1] = '\0';
      _posicion.z = atof(cad);
    }
    else if ( strcmp(cad, "velocidad") == 0 ) {
      tipo_token = Sabiondo->siguiente_token(cad);
      ESPERO(TK_VECTOR_INICIO, "el inicio de un VECTOR");
      _velocidad.x = atof(&cad[1]);
      tipo_token = Sabiondo->siguiente_token(cad);
      ESPERO(TK_NUMERO, "un numero (dato 2 de un VECTOR)");
      _velocidad.y = atof(cad);
      tipo_token = Sabiondo->siguiente_token(cad);
      ESPERO(TK_VECTOR_FIN, "el final de un VECTOR");
      cad[strlen(cad) - 1] = '\0';
      _velocidad.z = atof(cad);
    }
    else if ( strcmp(cad, "masa") == 0 ) {
      tipo_token = Sabiondo->siguiente_token(cad);
      ESPERO(TK_NUMERO, "un numero");
      _masa = atof(cad);
    }
    else if ( strcmp(cad, "ke") == 0 ) {
      tipo_token = Sabiondo->siguiente_token(cad);
      ESPERO(TK_NUMERO, "un numero");
      _ke = atof(cad);
      if ( _ke > 1 ) _ke = 1;
      if ( _ke < 0 ) _ke = 0;
    }
    else if ( strcmp(cad, "estoy_fijo") == 0 ) {
      tipo_token = Sabiondo->siguiente_token(cad);
      ESPERO(TK_IDENTIFICADOR, "un identificador (4)");
      for ( i = 0; cad[i]; i++ ) cad[i] = (char)toupper(cad[i]);
      if ( strstr(cad, "TRUE") || strstr(cad, "SI") ) {
          _estoy_fijo = TRUE;
        }
        else {
          _estoy_fijo = FALSE;
      }
    }
    else if ( strcmp(cad, "material") == 0 ) {
      tipo_token = Sabiondo->siguiente_token(cad);
      ESPERO(TK_CADENA, "una cadena");
      leer_material(cad);
    }
    else if ( strcmp(cad, "color") == 0 ) {
      tipo_token = Sabiondo->siguiente_token(cad);
      ESPERO(TK_VECTOR_INICIO, "el inicio de un COLOR");
      _color.r = (float)atof(&cad[1]);
      tipo_token = Sabiondo->siguiente_token(cad);
      ESPERO(TK_NUMERO, "un numero (dato 2 de un COLOR)");
      _color.g = (float)atof(cad);
      tipo_token = Sabiondo->siguiente_token(cad);
      ESPERO(TK_VECTOR_FIN, "el final de un COLOR");
      cad[strlen(cad) - 1] = '\0';
      _color.b = (float)atof(cad);
      (*cmc) = TRUE;
    }
    else if ( strcmp(cad, "padre") == 0 ) {
        tipo_token = Sabiondo->siguiente_token(cad);
        ESPERO(TK_CADENA, "el nombre de una cosa padre");
        des_comille(cad);
        _nombre_padre = new char[strlen(cad) + 1];
        if ( !_nombre_padre ) {
            fprintf(stderr, "<COSA> - ERROR: "
                "No hay memoria!\n");
            fflush(stderr);
            return FALSE;
        }
        strcpy(_nombre_padre, cad);
    }

    return TRUE;
}

void
COSA::limpiar_fuerzas(void)
{
    int i;

    for ( i = 0; i < lista_fuerzas_externas.tam(); i++ ) {
        delete lista_fuerzas_externas[i];
    }
    lista_fuerzas_externas.elim();
}

void
COSA::aplicar_campo_vectorial(CAMPO_VECTORIAL *Campo)
{
    VECTOR centro_de_masa(0,0,0);
    VECTOR p = posicion_absoluta(centro_de_masa);

    // OJO: Estas posiciones deben estar bien pensadas!
    anexar_fuerza(Campo->valor(p) * _masa, p);
}

void
COSA::aplicar_drag(double Kd)
{
    VECTOR centro_de_masa(0,0,0);

    // OJO: Estas posiciones deben estar bien pensadas!
    anexar_fuerza(velocidad_absoluta() * Kd,
      posicion_absoluta(centro_de_masa));
}

double
COSA::interseccion(RAYO * /*Rayo*/, VECTOR * /*punto*/, VECTOR * /*normal*/)
{

printf("Guepa!\n"); fflush(stdout);

    return 0;
}

VECTOR
COSA::velocidad_angular_absoluta(void)
{
    VECTOR nulo(0, 0, 0);

    // MUCHO OJO! Todavia no se sabe bien si es esto!
    return nulo;
}

void
COSA::set_velocidad_angular_absoluta(VECTOR /*omega*/)
{
    ;
}

MATRIZ_4x4
COSA::tensor_de_inercia(void)
{
    MATRIZ_4x4 identidad;  // OJO: No sera mejor retorna la matriz 0?

    return identidad;
}

void
COSA::pintar_povray(FILE *fd)
{
    fprintf(fd, "// <COSA> - WARNING: hay algo no definido!\n");
}

//===========================================================================
//= Clase COSA_FLEXIBLE                                                     =
//===========================================================================

COSA_FLEXIBLE::COSA_FLEXIBLE() : COSA()
{
    ;
}

COSA_FLEXIBLE::~COSA_FLEXIBLE()
{
    ;
}

//===========================================================================
//= 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.