camara.h

Ir a la documentación de este archivo.

//===========================================================================
//= camara.h                                            desde Julio de 1998 =
//=-------------------------------------------------------------------------=
//= Definiciones de la clase CAMARA                                         =
//=-------------------------------------------------------------------------=
//= 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 __CAMARA__
#define __CAMARA__

#include "jed_defs.h"  // Incluir antes que nada, en ese modulo se definen 
                       // aspectos importantes para la portabilidad del sistema
#include "entidad.h"
#include "jed_gl.h"
#include "color.h"
#include "matriz4.h"
#include "quaternion.h"
#include "toolkits/entorno/rayo.h"

enum ENUM_MODOS_DE_CAMARA {
    CAM_GLOBAL = 1,
    CAM_POS_MODELO,
    CAM_TOTAL_MODELO
};

enum ENUM_MODOS_DE_CONTROL_CAMARA {
    CAM_STANDARD = 4,
    CAM_VUELO
};

enum ENUM_TIPOS_PERSPECTIVAS {
    CAM_PERSPECTIVA = 6,
    CAM_PARALELA
};

enum ENUM_TIPOS_BILLBOARD {
    CAM_NO_CUADRAR = 0,
    CAM_CUADRAR_X,
    CAM_CUADRAR_Y,
    CAM_CUADRAR_MENOR
};

#define ACTIVAR_TRANSPARENCIA(t)                                \
    if ( (t) > 1.0 ) (t) = 1.0;                                 \
    if ( (t) < 0 ) (t) = 0;                                     \
    if ( (t) < 1.0 - EPSILON ) {                                \
        glEnable(GL_BLEND);                                     \
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);      \
    }

// OJO: Esta bien que vaya en este modulo?
// OJO: No sera mejor dejar los atributos privados y hacer amiga a la
// clase VISTA?
class CAMARA : public ENTIDAD 
{
  private:
    //- Atributos basicos del TAD CAMARA ------------------------------------
    VECTOR _posicion;        
    QUATERNION _orientacion; 
    double _fov;             
    double _near_plane;      


    double _far_plane;       


    int _modo_proyeccion;    
    double _zoom_paralelo;   



    //- Atributos especiales del modelo de CAMARA AQUYNZA -------------------
    ENTIDAD *_Padre;         
    char *_nombre_padre;     

    BOOLEAN mostrar_etiqueta; 


    double transparencia_etiqueta; 

    COLOR color_etiqueta;     

    int tipo_modelo;       
    int modo_seguimiento;  
    int modo_control;      

    //- Atributos de uso interno a la clase CAMARA --------------------------
    int _ventana_xtam;
    int _ventana_ytam;     

    BOOLEAN _con_posicion;

    VECTOR _up;     
    VECTOR _right;  
    VECTOR _dir;
    VECTOR _pos;

    //- Metodos privados utilitarios para la uso interno de la clase --------
    void pintar_base_gl(void);
    void pintar_volumen_gl(void);

  public:
    //- Operaciones basicas: control del TAD CAMARA ------------------------
    CAMARA();
    virtual ~CAMARA();

    VECTOR posicion(void);
    void set_posicion(VECTOR p);
    QUATERNION orientacion(void);
    void set_orientacion(QUATERNION o);
    double fov(void);
    void set_fov(double in_nuevo_fov);
    double far_plane(void);
    void set_far_plane(double f);
    double near_plane(void);
    void set_near_plane(double f);
    int modelo(void);
    void set_modelo(int val);

    //- Operaciones utilitarias --------------------------------------------
    void asociar_padre(ENTIDAD *p);
    char *nombre_padre(void);
    void preprocesar_vista(void);
    inline RAYO generar_rayo(int x, int y);
    void imprimir(void);
    BOOLEAN minmax_visible(VECTOR esquinas[8]);
    MATRIZ_4x4 calcular_matriz_de_proyeccion(int modo_stereo = 0);
    BOOLEAN proyectar_punto(VECTOR *in_P, double *out_U, double *out_V);

    //- Implementacion de la firma de ENTIDAD ------------------------------
    BOOLEAN
    consultar_variable(const char *nombre_variable, int &tipo, void **ref);

    //- Operaciones de visualizacion ---------------------------------------
  #ifdef GL_ENABLED
    void pintar_gl(void);
    void activar_gl(int modo_stereo = 0);
    void activar_centro_gl(void);
    void billboard_gl(int tipo); // uno de los TIPOS_BILLBOARD
    void subbillboard_gl(int tam, int x, int y, int dx, int dy, int cuadre);
  #endif
    void activar_povray(FILE *fd);

    //- Operaciones de soporte al manejo GUI -------------------------------
    BOOLEAN procesar_teclado(EVENTO_GUI *e);
    BOOLEAN procesar_mouse(EVENTO_GUI *e);
    void procesar_resize(int xtam, int ytam);
    double factor_font(void);

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

//===========================================================================
//= Metodos inline de la clase CAMARA                                       =
//===========================================================================

inline RAYO
CAMARA::generar_rayo(int x, int y)
{
    RAYO rayo;
    double mi_x, mi_y;
    VECTOR dx, dy;
    double vxt = (double)_ventana_xtam, vyt = (double)(_ventana_ytam);

    //- Convierte las coordenadas a flotantes entre -0.5 y 0.5 --------------
    mi_x = (x - vxt/2.0) / vxt;
    mi_y = ((vyt - y - 1) -  vyt/2.0) / vyt;

    //- Calcule el rayo -----------------------------------------------------
    rayo.origen.x = _pos.x;
    rayo.origen.y = _pos.y;
    rayo.origen.z = _pos.z;

    dy = _up * mi_y;
    dx = _right * mi_x;
    rayo.direccion = dx + dy;
    rayo.direccion = rayo.direccion + _dir;
    rayo.direccion.normalizar();

    //- Listo! --------------------------------------------------------------
    return rayo;
}

#endif // __CAMARA__

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