cosa.h

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

#ifndef __COSA__
#define __COSA__

#include "jed_defs.h"
#include "entidad.h"
#include "toolkits/geom/geometria.h"
#include "toolkits/geom/mesh.h"
#include "core/simul/solver.h"
#include "matriz4.h"
#include "core/campos/campo.h"

//===========================================================================
//= DEFINICION DE CLASES AUXILIARES                                         =
//===========================================================================

class FUERZA_PUNTO 
{
  public:
    VECTOR fuerza;
    VECTOR punto;
};

class RESORTE;

//===========================================================================
//= DEFINICION DE LA CLASE COSA                                             =
//===========================================================================

enum ENUM_CATEGORIAS_COSAS {
    CC_DESCONOCIDA = 0,
    CC_MASA_PUNTUAL,
    CC_COSA_RIGIDA,
    CC_TELA,
    CC_AVATAR_QUAKE,
    CC_ESPACIO_ABIERTO
};

class COSA : public ENTIDAD, public ECUACION_DIFERENCIAL
{
  private:
    void leer_material(char *nombre); 

  protected:
    //- Variables fisicas basicas -------------------------------------------
    VECTOR _posicion;        

    VECTOR _velocidad;       
    double _masa;            
    double _ke;              


    //- Artificios del modelo AQUYNZA ---------------------------------------
    BOOLEAN _estoy_fijo;     

    MATERIAL *Material;      
    COLOR _color;            
    COSA *Padre;             

    char *_nombre_padre;

    // Informacion calculada dinamicamente
    int _tipo_de_cosa;       
    LISTA<FUERZA_PUNTO *>    
        lista_fuerzas_externas;    

    //- Servicios privados --------------------------------------------------
    void limpiar_fuerzas(void);  
    BOOLEAN
    leer_basico(TOKENIZADOR *Sabiondo, char *cad, BOOLEAN *cmc);
    void grabar_basico(FILE *fd);

  public:
    //- Operaciones basicas (manejo de la representacuon) -------------------
    COSA();                  
    virtual ~COSA();         
    virtual COSA *crear_copia(void); 
    inline double masa(void);
    inline double ke(void);
    virtual BOOLEAN          
    consultar_variable(const char *nombre_variable, int &tipo, void **ref);
    BOOLEAN
    actualizar_variable(const char *nombre_variable, int tipo, void *ref);
    char *nombre_padre(void);
    void asociar_padre(COSA *p);
    BOOLEAN estoy_fijo(void);
    int tipo_de_cosa(void);

    //- Operaciones basicas (fisicas) ---------------------------------------
    VECTOR posicion(void);   

    virtual VECTOR posicion_absoluta(VECTOR p);
    virtual QUATERNION orientacion_absoluta(void);
    inline VECTOR velocidad_absoluta(void);
    inline void set_posicion_absoluta(VECTOR p);
    inline void set_velocidad_absoluta(VECTOR v);
    virtual VECTOR velocidad_angular_absoluta(void);
    virtual void set_velocidad_angular_absoluta(VECTOR omega);
    virtual MATRIZ_4x4 tensor_de_inercia(void);
    virtual GEOMETRIA *geometria(void) = 0;
    inline void anexar_fuerza(VECTOR fuerza, VECTOR p);
    virtual void aplicar_campo_vectorial(CAMPO_VECTORIAL *Campo);
    virtual void aplicar_drag(double Kd);
    double altura(VECTOR p);

    //- Operaciones de simulacion -------------------------------------------
    virtual void actualizar(double delta_t) = 0;
    virtual int ODE_numero_de_variables_de_estado(void) = 0;
    virtual void ODE_reportar_variables_de_estado(double *Datos) = 0;
    virtual void ODE_actualizar_variables_de_estado(double *Datos) = 0;
    virtual void ODE_calcular_la_primera_derivada(double *Datos) = 0;

    //- Operaciones de consulta y visualizacion -----------------------------
    virtual void minmax(VECTOR *min, VECTOR *max) = 0;
    virtual double interseccion(RAYO *Rayo, VECTOR *Punto, VECTOR *Normal);

#ifdef GL_ENABLED
    virtual void pintar_gl(CALIDAD_VISUAL *Calidad, CAMARA *Camara) = 0;
#endif
    virtual void pintar_povray(FILE *fd);
    MATERIAL *material(void);
    COLOR color(void);

    //- Operaciones de persistencia -----------------------------------------
    virtual BOOLEAN leer(TOKENIZADOR *Sabiondo) = 0;
    virtual BOOLEAN resolver(LISTA <COSA *> *Cosas);
    virtual void grabar(FILE *fd) = 0;
};

inline double
COSA::masa(void)
{
    return _masa;
}

inline double
COSA::ke(void)
{
    return _ke;
}

inline VECTOR
COSA::velocidad_absoluta(void)
{
    // MUCHO OJO! No se ha implementado! Debe utilizar la _orientacion, la
    // _velocidad y la velocidad_absoluta del padre si lo hay!
    return _velocidad;
}

inline void
COSA::set_velocidad_absoluta(VECTOR v)
{
    // MUCHO OJO! No se ha implementado! Debe utilizar la _orientacion, la
    // _velocidad y la velocidad_absoluta del padre si lo hay!
    _velocidad = v;
}

inline void
COSA::set_posicion_absoluta(VECTOR p)
{
    // MUCHO OJO! No se ha implementado! Debe utilizar la _orientacion, la
    // _posicion y la posicion_absoluta del padre si lo hay!
    _posicion = p;
}

inline void
COSA::anexar_fuerza(VECTOR fuerza, VECTOR p)
{
    FUERZA_PUNTO *F = new FUERZA_PUNTO;

    if ( !F ) {
        fprintf(stderr, "<COSA> - ERROR de memoria insertando una fuerza!\n");
        fflush(stderr);
        return;
    }

    F->fuerza = fuerza;
    F->punto = p;
    lista_fuerzas_externas.anx(F);
}

//===========================================================================
//= DEFINICION DE LA JERARQUIA DE CLASES DE COSAS                           =
//===========================================================================

class TELA;

class MASA_PUNTUAL : public COSA
{
  public:
    BOOLEAN en_colision; // OJO: Esto es machete!
 
    //- Operaciones basicas (manejo de la representacuon) -------------------
    MASA_PUNTUAL();
    virtual ~MASA_PUNTUAL();
    virtual COSA *crear_copia(void);
    BOOLEAN
    consultar_variable(const char *nombre_variable, int &tipo, void **ref);

    //- Operaciones basicas (fisicas) ---------------------------------------
    GEOMETRIA *geometria(void);  // OJO: Retorna NULL!

    //- Operaciones de simulacion -------------------------------------------
    void actualizar(double delta_t);
    int ODE_numero_de_variables_de_estado(void);
    void ODE_reportar_variables_de_estado(double *Datos);
    void ODE_actualizar_variables_de_estado(double *Datos);
    void ODE_calcular_la_primera_derivada(double *Datos);

    //- Operaciones de consulta (visualizacion) -----------------------------
    void minmax(VECTOR *min, VECTOR *max);
#ifdef GL_ENABLED
    void pintar_gl(CALIDAD_VISUAL *Calidad, CAMARA *Camara);
#endif
    void pintar_povray(FILE *fd);

    //- Operaciones de persistencia -----------------------------------------
    BOOLEAN leer(TOKENIZADOR *Sabiondo);
    void grabar(FILE *fd);

    friend class TELA; // Acceso irrestringido por razones de eficiencia!
};

class COSA_RIGIDA : public COSA
{
  protected:
    //- Variables fisicas basicas -------------------------------------------
    VECTOR _centro_de_masa;  // Posicion relativa al centro geometrico
    VECTOR _velocidad_angular;
    QUATERNION _orientacion;
    MATRIZ_4x4 tensor_de_inercia_0; // Modela la distribucion de la masa

    BOOLEAN leer_rigida(TOKENIZADOR *Sabiondo, char *cad);
    void resolver_tensor_de_inercia(void);

  private:
    GEOMETRIA *Geometria;
    double _ultimo_Kd; // Ultimo coeficiente de viscosidad

  public:
    //- Operaciones basicas (manejo de la representacuon) -------------------
    COSA_RIGIDA();
    virtual ~COSA_RIGIDA();
    virtual COSA *crear_copia(void);
    BOOLEAN
    consultar_variable(const char *nombre_variable, int &tipo, void **ref);
    BOOLEAN
    actualizar_variable(const char *nombre_variable, int tipo, void *ref);
    //- Operaciones basicas (fisicas) ---------------------------------------
    GEOMETRIA *geometria(void);
    VECTOR posicion_absoluta(VECTOR p); // Redefine la de COSA
    VECTOR velocidad_angular_absoluta(void);
    void set_velocidad_angular_absoluta(VECTOR omega);
    MATRIZ_4x4 tensor_de_inercia(void);
    QUATERNION orientacion_absoluta(void);
    void set_orientacion_absoluta(QUATERNION q);
    void aplicar_drag(double Kd);

    //- Operaciones de simulacion -------------------------------------------
    void tick(void);  // OJO: Esto debe borrarse! - Es una prueba!
    void actualizar(double delta_t);
    int ODE_numero_de_variables_de_estado(void);
    void ODE_reportar_variables_de_estado(double *Datos);
    void ODE_actualizar_variables_de_estado(double *Datos);
    void ODE_calcular_la_primera_derivada(double *Datos);

    //- Operaciones de consulta (visualizacion) -----------------------------
    void minmax(VECTOR *min, VECTOR *max);
    virtual double interseccion(RAYO *Rayo, VECTOR *Punto, VECTOR *Normal);
#ifdef GL_ENABLED
    void pintar_gl(CALIDAD_VISUAL *Calidad, CAMARA *Camara);
#endif
    void pintar_povray(FILE *fd);

    //- Operaciones de persistencia -----------------------------------------
    BOOLEAN leer(TOKENIZADOR *Sabiondo);
    BOOLEAN resolver(LISTA <COSA *> *Cosa);
    void grabar(FILE *fd);
};

class COSA_FLEXIBLE : public COSA {
  public:
    COSA_FLEXIBLE();
    virtual ~COSA_FLEXIBLE();

    //- Operaciones basicas (manejo de la representacuon) -------------------
    virtual GEOMETRIA *geometria(void) = 0;

    //- Operaciones de simulacion -------------------------------------------
    virtual void actualizar(double delta_t) = 0;
    virtual int ODE_numero_de_variables_de_estado(void) = 0;
    virtual void ODE_reportar_variables_de_estado(double *Datos) = 0;
    virtual void ODE_actualizar_variables_de_estado(double *Datos) = 0;
    virtual void ODE_calcular_la_primera_derivada(double *Datos) = 0;

    //- Operaciones de consulta (visualizacion) -----------------------------
    virtual void minmax(VECTOR *min, VECTOR *max) = 0;
#ifdef GL_ENABLED
    virtual void pintar_gl(CALIDAD_VISUAL *Calidad, CAMARA *Camara) = 0;
#endif
    virtual void pintar_povray(FILE *fd) = 0;

    //- Operaciones de persistencia -----------------------------------------
    virtual BOOLEAN leer(TOKENIZADOR *Sabiondo) = 0;
};

class TELA : public COSA_FLEXIBLE {
  private:
    //- Modelo fisico de la tela (tomado del modelo de o-fuente) ------------
    RESORTE *plantilla[3]; // Contiene las propiedades de los 3 tipos de 
                          // resorte del modelo MASA_PUNTUAL/RESORTE
    int x_tam;            // Cota al tamanno de la malla de masas en el
    int y_tam;            // modelo de la tela
    MASA_PUNTUAL *Arr_masas;  // Arreglo dinamico de x_tam * y_tam MASAS.
    RESORTE *Resortes1;  // Estos son arreglos dinamicos con sus tamannos
    int num_resortes1;    // para cada uno de los tres tipos de resortes
    RESORTE *Resortes2;  // definidos en el modelo masa/resorte de
    int num_resortes2;    // Omar Fuentes (o-fuente).
    RESORTE *Resortes3;  
    int num_resortes3;    

    //- Artificios AQUYNZA --------------------------------------------------
    BOOLEAN recien_simulado;  
    IMAGEN *Textura;
    MESH *Superficie;

    BOOLEAN leer_resortes(TOKENIZADOR *Sabiondo, int tipo);
    BOOLEAN leer_malla(TOKENIZADOR *Sabiondo);
    BOOLEAN precalcular_resortes(void);

    //- Operaciones para la administracion de la malla de triangulos --------
    VECTOR calcule_subnormal(int i1,int j1,int i2,int j2,int i3,int j3);
    VECTOR calcule_normal(int i, int j);

  public:
    TELA();
    virtual ~TELA();

    //- Operaciones basicas (manejo de la representacuon) -------------------
    GEOMETRIA *geometria(void);
    void aplicar_campo_vectorial(CAMPO_VECTORIAL *Campo);
    void aplicar_drag(double Kd);

    //- Operaciones de simulacion -------------------------------------------
    void actualizar(double delta_t);
    int ODE_numero_de_variables_de_estado(void);
    void ODE_reportar_variables_de_estado(double *Datos);
    void ODE_actualizar_variables_de_estado(double *Datos);
    void ODE_calcular_la_primera_derivada(double *Datos);

    //- Operaciones de consulta (visualizacion) -----------------------------
    void minmax(VECTOR *min, VECTOR *max);
#ifdef GL_ENABLED
    void pintar_gl(CALIDAD_VISUAL *Calidad, CAMARA *Camara);
#endif
    void pintar_povray(FILE *fd);

    //- Operaciones de persistencia -----------------------------------------
    BOOLEAN leer(TOKENIZADOR *Sabiondo);
    void grabar(FILE *fd);

    //- Especificas de la tela ----------------------------------------------
    inline int num_masas(void);
    inline MASA_PUNTUAL *masa_puntual(int i);
};

class AVATAR_QUAKE : public COSA_FLEXIBLE {
  private:
    //- Artificios AQUYNZA --------------------------------------------------
    IMAGEN *Textura;
    MESH *Superficie;

  public:
    AVATAR_QUAKE();
    virtual ~AVATAR_QUAKE();

    //- Operaciones basicas (manejo de la representacuon) -------------------
    GEOMETRIA *geometria(void);

    //- Operaciones de simulacion -------------------------------------------
    void actualizar(double delta_t);

    //- Operaciones de consulta (visualizacion) -----------------------------
#ifdef GL_ENABLED
    void pintar_gl(CALIDAD_VISUAL *Calidad, CAMARA *Camara);
#endif
    void pintar_povray(FILE *fd);

    //- Operaciones de persistencia -----------------------------------------
    BOOLEAN leer(TOKENIZADOR *Sabiondo);
    void grabar(FILE *fd);
};

inline int
TELA::num_masas(void)
{
    return x_tam * y_tam;
}

inline MASA_PUNTUAL *
TELA::masa_puntual(int i)
{
    return &Arr_masas[i];
}

#ifndef VEL_ROSITA
    #include "core/uniones/union.h"
#endif

#endif // __COSA__

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