Página principal | Jerarquía de la clase | Lista alfabética | Lista de componentes | Lista de archivos | Miembros de las clases | Archivos de los miembros | Páginas relacionadas

Referencia de la Clase CAMARA

El modelo básico de una CAMARA consta de una `_posicion`, una `orientacion`, un ángulo de visión (`_fov`), un plano cercano (`_near_plane`), un plano lejano (`_far_plane`), un `_modo_de_proyeccion` y unos parametros adicionales (`_zoom_paralelo`), que en conjunto, son suficientes para especificar un volumen de visualización para realizar recorte 3D de las primitivas de una escena, y para especificar una superficie de proyección. Más...

#include <camara.h>

Diagrama de herencias de CAMARA

Inheritance graph
[leyenda]
Diagrama de colaboración para CAMARA:

Collaboration graph
[leyenda]
Lista de todos los miembros.

Métodos públicos

 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)
 Este metodo activa (con TRUE) o desactiva (con FALSE) la generacion de una representacion grafica de la camara (vea el metodo `pintar_gl`).

void asociar_padre (ENTIDAD *p)
char * nombre_padre (void)
void preprocesar_vista (void)
 Precalcula los valores de los atributos temporales `_pos`, `_up`, `_right` y `_dir`, que se usan en los metodos `generar_rayo` y `activar_povray`.

RAYO generar_rayo (int x, int y)
 Calcula el RAYO que desde el punto donde esta localizada esta camara pasa por el pixel (x, y) del "viewport", que esta en el plano de proyeccion de esta camara.

void imprimir (void)
BOOLEAN minmax_visible (VECTOR esquinas[8])
 Este metodo determina si un paralelogramo (que no necesariamente esta alineado con los ejes principales) intersecta o no el volumen de visualizacion.

MATRIZ_4x4 calcular_matriz_de_proyeccion (int modo_stereo=0)
 Calcula una matriz de proyeccion planar geometrica que sea consistente con el estado actual de la camara.

BOOLEAN proyectar_punto (VECTOR *in_P, double *out_U, double *out_V)
 Dado un punto `*in_P` en coordenadas absolutas, se calcula un punto P', que se encuentra ubicado en el plano de proyección y cuyas coordenadas relativas a dicho plano son (*out_U, *out_V).

BOOLEAN consultar_variable (const char *nombre_variable, int &tipo, void **ref)
 En este metodo se define el comportamiento por basico de acceso a variables para cosas.

void pintar_gl (void)
 Este metodo genera una representacion OpenGL visible de una camara.

void activar_gl (int modo_stereo=0)
 Tenga en cuenta la representacion interna de la camara de AQUYNZA: una camara tiene una posicion y una orientacion...

void activar_centro_gl (void)
 Esta variacion del metodo `activar_gl` se utiliza para activar solo la proyeccion y orientacion de la camara en operaciones tipicamente de trazado de fondos (i.e.

void billboard_gl (int tipo)
 Inicializa una proyeccion ortogonal para la vista actual de tal manera que al pintar objetos 2D, estos queden enmarcados dentro de la zona (-1, -1) - (1, 1) y este marco coincida con un area de la ventana asi: CAM_NO_CUADRAR: el cuadro es del tamanno de la ventana CAM_CUADRAR_X: el cuadro es cuadrado y tiene el ancho de la ventana CAM_CUADRAR_Y: el cuadro es cuadrado tiene el alto de la ventana CAM_CUADRAR_MENOR: el cuadro es cuadrado y tiene el alto o el ancho de la ventana, y ademas esta completamente contenido en la misma.

void subbillboard_gl (int tam, int x, int y, int dx, int dy, int cuadre)
 Activa el viewport de manera tal que corresponda a una la celda imaginaria (x,y)-(x+dx, y+dy) dentro de una cuadricula de tam x tam pedazos sobre el cuadro definido por billboard_gl(CAM_CUADRAR_MENOR).

void activar_povray (FILE *fd)
 Este método escribe en el archivo `*fd` las primitivas POVray necesarias para especificar la CAMARA `*this` en la escena POV.

BOOLEAN procesar_teclado (EVENTO_GUI *e)
 Este metodo recibe un evento de teclado y cambia el estado de la camara.

BOOLEAN procesar_mouse (EVENTO_GUI *e)
void procesar_resize (int xtam, int ytam)
double factor_font (void)
BOOLEAN leer (TOKENIZADOR *Sabiondo)

Métodos privados

void pintar_base_gl (void)
void pintar_volumen_gl (void)

Atributos privados

VECTOR _posicion
 Posición de la CAMARA.

QUATERNION _orientacion
 Orientación de la CAMARA.

double _fov
 Ángulo de visión (apertura)

double _near_plane
 Distancia al plano cercano del volumen de visualización al centro de proyección de la CAMARA.

double _far_plane
 Distancia al plano lejano del volumen de visualización al centro de proyección de la CAMARA.

int _modo_proyeccion
 Una de las `ENUM_TIPOS_PERSPECTIVAS`.

double _zoom_paralelo
 Usado cuando _modo_proyeccion = CAM_PARALELA, representa un valor en aumentos, que por defecto es 1 y debe ser mayor a EPSILON.

ENTIDAD * _Padre
 Una camara puede asociarse a una ENTIDAD!

char * _nombre_padre
 OJO: Esto no es redundante?

BOOLEAN mostrar_etiqueta
 TRUE si el nombre de la cámara se muestra sobre el viewport en la capa "cockpit" (vicera de piloto en transparente).

double transparencia_etiqueta
 `mostrar_etiqueta` es TRUE

COLOR color_etiqueta
 Usado si `mostrar_etiqueta` es TRUE.

int tipo_modelo
 Para pintar_gl() -> Deberia llamarse "modo".

int modo_seguimiento
 uno de los MODOS_DE_CAMARA

int modo_control
 uno de los MODOS_DE_CONTROL_CAMARA

int _ventana_xtam
 Una `CAMARA` debe saber de qué tamaño es el viewport para el cual está generando una proyección, para poder modificar sus parámetros internos en función del ángulo de vision (`_fov`) y de la actual proporción de ancho/alto del viewport.

int _ventana_ytam
 Ver la documentación de `_ventana_xtam`.

BOOLEAN _con_posicion
 Existen ciertas ocaciones en las cuales una aplicación puede necesitar activar la orientación de una CAMARA sin activar su posicion.

VECTOR _up
 Los `VECTOR`es `_up`, `_right`, `_dir` y `_pos` son variables temporales para calculadas dentro del método `CAMARA::preprocesar_vista`, y para uso interno de los demás métodos de la clase.

VECTOR _right
VECTOR _dir
VECTOR _pos

Descripción detallada

El modelo básico de una CAMARA consta de una `_posicion`, una `orientacion`, un ángulo de visión (`_fov`), un plano cercano (`_near_plane`), un plano lejano (`_far_plane`), un `_modo_de_proyeccion` y unos parametros adicionales (`_zoom_paralelo`), que en conjunto, son suficientes para especificar un volumen de visualización para realizar recorte 3D de las primitivas de una escena, y para especificar una superficie de proyección.

Debe tenerse en cuenta lo siguiente:

Definición en la línea 68 del archivo camara.h.

Documentación del constructor y destructor

CAMARA::CAMARA (   ) 
 

Definición en la línea 87 del archivo camara.C.

References _con_posicion, _far_plane, _fov, _modo_proyeccion, _near_plane, _nombre_padre, _orientacion, _Padre, _posicion, _ventana_xtam, _ventana_ytam, COLOR::b, CAM_GLOBAL, CAM_PERSPECTIVA, CAM_STANDARD, color_etiqueta, COLOR::g, QUATERNION::importar_angulo_eje(), modo_control, modo_seguimiento, mostrar_etiqueta, COLOR::r, tipo_modelo, transparencia_etiqueta, VECTOR::x, VECTOR::y, y VECTOR::z.

Here is the call graph for this function:

CAMARA::~CAMARA (   )  [virtual]
 

Definición en la línea 122 del archivo camara.C.

References _nombre_padre.

Documentación de las funciones miembro

void CAMARA::activar_centro_gl (  void   ) 
 

Esta variacion del metodo `activar_gl` se utiliza para activar solo la proyeccion y orientacion de la camara en operaciones tipicamente de trazado de fondos (i.e.

visualizacion de objetos "infinitamente lejanos" cuyas posiciones aparentes no varian en funcion de la localizacion de la camara).

Definición en la línea 830 del archivo camara.C.

References _con_posicion, _posicion, activar_gl(), VECTOR::x, VECTOR::y, y VECTOR::z.

Referenciado por FONDO_MAPA_DE_ENTORNO::pintar_gl(), y FONDO_ESTRELLAS::pintar_gl().

Here is the call graph for this function:

void CAMARA::activar_gl (  int  modo_stereo = 0  ) 
 

Tenga en cuenta la representacion interna de la camara de AQUYNZA: una camara tiene una posicion y una orientacion...

es decir que "esta en algun lado dirigiendo su mirada hacia alguna direccion". Dado que la direccion es un quaternion y OpenGL trabaja con matrices, aqui puede verse como se le pasa a OpenGL una matriz transformada `R` (con la posicion y translacion) en el modo GL_PROJECTION.

Ese proceso de transformacion geometrica se hace despues de espefificarle a OpenGL su debida matriz de proyeccion.

Dependiendo del modo_stereo se hace una de 3 cosas: 0: La proyeccion es la normal 1: Se altera la proyeccion para generar la perspectiva de un ojo izquierdo 2: Se altera la proyeccion para generar la perspectiva de un ojo derecho

Definición en la línea 790 del archivo camara.C.

References calcular_matriz_de_proyeccion(), MATRIZ_4x4::cargar_gl(), MATRIZ_4x4::importar_gl(), y MATRIZ_4x4::imprimir().

Referenciado por activar_centro_gl(), VISOR_GEOMETRIA::pintar_gl(), VISOR_CAMPO_VECTORIAL::pintar_gl(), y VISOR_SENSOR_VECTOR::pintar_vector_gl().

Here is the call graph for this function:

void CAMARA::activar_povray (  FILE *  fd  ) 
 

Este método escribe en el archivo `*fd` las primitivas POVray necesarias para especificar la CAMARA `*this` en la escena POV.

Nótese que se realiza un truco para convertir el sistema de coordenadas de mano derecha AQUYNZA al sistema de coordenadas de mano izquierda POV: cambiar el signo de la componente y del vector `_right`.

Definición en la línea 1019 del archivo camara.C.

References _dir, _pos, _right, _up, preprocesar_vista(), VECTOR::x, VECTOR::y, y VECTOR::z.

Here is the call graph for this function:

void CAMARA::asociar_padre (  ENTIDAD *  p  ) 
 

Definición en la línea 156 del archivo camara.C.

References _Padre.

void CAMARA::billboard_gl (  int  tipo  ) 
 

Inicializa una proyeccion ortogonal para la vista actual de tal manera que al pintar objetos 2D, estos queden enmarcados dentro de la zona (-1, -1) - (1, 1) y este marco coincida con un area de la ventana asi: CAM_NO_CUADRAR: el cuadro es del tamanno de la ventana CAM_CUADRAR_X: el cuadro es cuadrado y tiene el ancho de la ventana CAM_CUADRAR_Y: el cuadro es cuadrado tiene el alto de la ventana CAM_CUADRAR_MENOR: el cuadro es cuadrado y tiene el alto o el ancho de la ventana, y ademas esta completamente contenido en la misma.

Este metodo ademas coloca una etiqueta de camara en el billboard programado.

OJO: Desde el punto de vista formal, el nombre de `billboard` no esta bien dado, porque un billboard puede estar en la escena (lo que define un "billboard" es que todo el tiempo este orientado hacia la camara). Bien, pues si se le ocurre un mejor nombre para esta operacion... propongalo!

Definición en la línea 895 del archivo camara.C.

References _ventana_xtam, _ventana_ytam, COLOR::b, BOOLEAN, CAM_CUADRAR_MENOR, CAM_CUADRAR_X, CAM_CUADRAR_Y, CAM_NO_CUADRAR, chequear_fuente(), color_etiqueta, factor_font(), COLOR::g, mostrar_etiqueta, ENTIDAD::nombre(), COLOR::r, y transparencia_etiqueta.

Referenciado por VISOR_SENSOR_VECTOR::pintar_gl().

Here is the call graph for this function:

MATRIZ_4x4 CAMARA::calcular_matriz_de_proyeccion (  int  modo_stereo = 0  ) 
 

Calcula una matriz de proyeccion planar geometrica que sea consistente con el estado actual de la camara.

Esta matriz de proyeccion podra ser usada dentro de cualquier secuencia de visualizacion (i.e. no depende de ninguna libreria externa particular, y en especial, no depende de OpenGL).

Definición en la línea 507 del archivo camara.C.

References _con_posicion, _far_plane, _fov, _modo_proyeccion, _near_plane, _orientacion, _Padre, _posicion, _ventana_xtam, _ventana_ytam, arr, CAM_PARALELA, CAM_PERSPECTIVA, ENTIDAD::consultar_variable(), MATRIZ_4x4::frustum(), MATRIZ_4x4::importar_quaternion(), MATRIZ_4x4::inversa(), MATRIZ_4x4::M, MATRIZ_4x4::ortho(), MATRIZ_4x4::rotacion_eje(), T_QUATERNION, T_VECTOR, MATRIZ_4x4::translacion(), VECTOR::x, VECTOR::y, y VECTOR::z.

Referenciado por activar_gl().

Here is the call graph for this function:

BOOLEAN CAMARA::consultar_variable (  const char *  nombre_variable,
int &  tipo,
void **  ref
)  [virtual]
 

En este metodo se define el comportamiento por basico de acceso a variables para cosas.

Notese que como el metodo es virtual, puede ser redefinido por las clases que hereden de COSA. Es util llamar este metodo dentro de sus redefiniciones, usando COSA::demevariable();

OJO: En este metodo se esta violando el principio de encapsulamiento de datos! Esto debe redisennarse!

Reimplementado de ENTIDAD.

Definición en la línea 170 del archivo camara.C.

References _orientacion, _posicion, T_QUATERNION, T_VECTOR, y TMP_quaternion.

double CAMARA::factor_font (  void   ) 
 

Definición en la línea 889 del archivo camara.C.

References _ventana_xtam.

Referenciado por billboard_gl(), VISOR_SENSOR_VECTOR::pintar_vistavion1_gl(), y VISOR_SENSOR_VECTOR::pintar_vistavion2_gl().

double CAMARA::far_plane (  void   ) 
 

Definición en la línea 134 del archivo camara.C.

References _far_plane.

double CAMARA::fov (  void   ) 
 

Definición en la línea 157 del archivo camara.C.

References _fov.

RAYO CAMARA::generar_rayo (  int  x,
int  y
)  [inline]
 

Calcula el RAYO que desde el punto donde esta localizada esta camara pasa por el pixel (x, y) del "viewport", que esta en el plano de proyeccion de esta camara.

OJO: Esto solo funciona para camaras configuradas con proyeccion perspectiva. Deberia tenerse en cuenta el caso paralelo... (pero, ojo, usar version inline `generar_rayo_paralelo` o algo asi, para no meter un `if` aqui)

Postcondición:

\[ \mathbf{Q} := rayo.direccion.norma() = 1 \]

Nótese que esta postcondición es importante, pues los algoritmos de seguimientos de rayos construidos a partir de este método pueden hacer optimizaciones (i.e. evitar tener que volver a llamar a la normalizacion del vector de dirección).

Definición en la línea 243 del archivo camara.h.

References _dir, _pos, _right, _up, _ventana_xtam, _ventana_ytam, RAYO::direccion, VECTOR::normalizar(), RAYO::origen, VECTOR::x, VECTOR::y, y VECTOR::z.

Referenciado por RAYTRACER_CRIOLLO::ejecutar(), y GIZMO_3D_TRANSLACION_3DSMAX::procesar_mouse().

Here is the call graph for this function:

void CAMARA::imprimir (  void   ) 
 

Definición en la línea 1050 del archivo camara.C.

References _far_plane, _fov, _modo_proyeccion, _near_plane, _orientacion, _posicion, _up, CAM_PARALELA, CAM_PERSPECTIVA, DEG2gms(), DEG2hms(), MATRIZ_4x4::exportar_angulos_euler(), MATRIZ_4x4::importar_quaternion(), ENTIDAD::nombre(), preprocesar_vista(), VECTOR::x, VECTOR::y, y VECTOR::z.

Referenciado por procesar_teclado().

Here is the call graph for this function:

BOOLEAN CAMARA::leer (  TOKENIZADOR *  Sabiondo  ) 
 

Definición en la línea 1288 del archivo camara.C.

References _far_plane, _fov, _modo_proyeccion, _near_plane, _nombre_padre, _orientacion, _posicion, COLOR::b, CAM_PARALELA, CAM_PERSPECTIVA, color_etiqueta, des_comille(), MATRIZ_4x4::exportar_quaternion(), COLOR::g, QUATERNION::importar_angulo_eje(), mostrar_etiqueta, VECTOR::normalizar(), COLOR::r, MATRIZ_4x4::rotacion_angulos_euler(), ENTIDAD::set_nombre(), TOKENIZADOR::siguiente_token(), tipo_modelo, TK_ABRIR, TK_CADENA, TK_CERRAR, TK_DESCONOCIDO, TK_IDENTIFICADOR, TK_NUMERO, TK_VECTOR_FIN, TK_VECTOR_INICIO, transparencia_etiqueta, VECTOR::x, VECTOR::y, y VECTOR::z.

Here is the call graph for this function:

BOOLEAN CAMARA::minmax_visible (  VECTOR  esquinas[8]  ) 
 

Este metodo determina si un paralelogramo (que no necesariamente esta alineado con los ejes principales) intersecta o no el volumen de visualizacion.

El paralelogramo a probar esta definido por sus 8 extremos (en un arreglo de 8 VECTORes que tiene las coordenadas de los 8 vertices). Si el paralelogramo se intersecta con el volumen de visualizacion de esta camara, entonces es "visible" y se retorna TRUE. De lo contrario se retorna FALSE.

OJO: Esta funcion NO se ha terminado de desarrollar! Aunque ya funciona, notese que las definiciones de plano punto/normal pueden ser preprocesados cada vez que se altere el estado de la camara, y no todas las veces que se llame este metodo. Se suguiere crear un CAMARA::init().

Definición en la línea 194 del archivo camara.C.

References _con_posicion, _far_plane, _fov, _modo_proyeccion, _near_plane, _orientacion, _Padre, _posicion, _ventana_xtam, _ventana_ytam, BOOLEAN, CAM_PARALELA, ENTIDAD::consultar_variable(), MATRIZ_4x4::importar_quaternion(), VECTOR::normalizar(), VECTOR::producto_punto(), T_QUATERNION, T_VECTOR, MATRIZ_4x4::translacion(), VECTOR::x, VECTOR::y, y VECTOR::z.

Referenciado por ESPACIO_ABIERTO::pintar_gl(), y COSA_RIGIDA::pintar_gl().

Here is the call graph for this function:

int CAMARA::modelo (  void   ) 
 

Definición en la línea 729 del archivo camara.C.

References tipo_modelo.

double CAMARA::near_plane (  void   ) 
 

Definición en la línea 146 del archivo camara.C.

References _near_plane.

char * CAMARA::nombre_padre (  void   ) 
 

Definición en la línea 155 del archivo camara.C.

References _nombre_padre.

QUATERNION CAMARA::orientacion (  void   ) 
 

Definición en la línea 152 del archivo camara.C.

References _orientacion.

Referenciado por BSP_2D::pintar_bsp().

void CAMARA::pintar_base_gl (  void   )  [private]
 

Definición en la línea 609 del archivo camara.C.

References PINTAR_VECTOR_GL().

Referenciado por pintar_gl().

Here is the call graph for this function:

void CAMARA::pintar_gl (  void   ) 
 

Este metodo genera una representacion OpenGL visible de una camara.

Notese que esta operacion puede desactivarse o activarse con `set_modelo`.

OJO: No confundir con `activar_gl`.

Definición en la línea 735 del archivo camara.C.

References _con_posicion, _orientacion, _Padre, _posicion, MATRIZ_4x4::cargar_gl(), ENTIDAD::consultar_variable(), MATRIZ_4x4::importar_quaternion(), pintar_base_gl(), pintar_volumen_gl(), T_QUATERNION, T_VECTOR, tipo_modelo, MATRIZ_4x4::translacion(), VECTOR::x, VECTOR::y, y VECTOR::z.

Here is the call graph for this function:

void CAMARA::pintar_volumen_gl (  void   )  [private]
 

Definición en la línea 626 del archivo camara.C.

References _far_plane, _fov, _modo_proyeccion, _near_plane, _ventana_xtam, _ventana_ytam, y CAM_PARALELA.

Referenciado por pintar_gl().

VECTOR CAMARA::posicion (  void   ) 
 

Definición en la línea 151 del archivo camara.C.

References _posicion.

Referenciado por BSP_2D::pintar_bsp(), y SISTEMA_DE_PARTICULAS::pintar_gl().

void CAMARA::preprocesar_vista (  void   ) 
 

Precalcula los valores de los atributos temporales `_pos`, `_up`, `_right` y `_dir`, que se usan en los metodos `generar_rayo` y `activar_povray`.

OJO: Hay que revisar las matematicas de esto! En particular... porqué es equivalente a lo que hace OpenGL?

Definición en la línea 451 del archivo camara.C.

References _con_posicion, _dir, _fov, _orientacion, _Padre, _pos, _posicion, _right, _up, _ventana_xtam, _ventana_ytam, ENTIDAD::consultar_variable(), MATRIZ_4x4::importar_quaternion(), MATRIZ_4x4::inversa(), T_QUATERNION, T_VECTOR, MATRIZ_4x4::translacion(), VECTOR::x, VECTOR::y, y VECTOR::z.

Referenciado por activar_povray(), RAYTRACER_CRIOLLO::ejecutar(), imprimir(), GIZMO_3D_TRANSLACION_3DSMAX::procesar_mouse(), y proyectar_punto().

Here is the call graph for this function:

BOOLEAN CAMARA::procesar_mouse (  EVENTO_GUI *  e  ) 
 

Definición en la línea 1217 del archivo camara.C.

References _orientacion, _posicion, BOOLEAN, ETYPE_BUTTON_DOWN, ETYPE_BUTTON_UP, MATRIZ_4x4::importar_quaternion(), MATRIZ_4x4::M, EVENTO_GUI::mouse_button_mask, EVENTO_GUI::mouse_delta_x, EVENTO_GUI::mouse_delta_y, QUATERNION::normalizar(), MATRIZ_4x4::rotacion_eje(), EVENTO_GUI::tipo_de_evento, VECTOR::x, VECTOR::y, y VECTOR::z.

Referenciado por VISOR_GEOMETRIA::procesar_mouse().

Here is the call graph for this function:

void CAMARA::procesar_resize (  int  xtam,
int  ytam
) 
 

Definición en la línea 1279 del archivo camara.C.

References _ventana_xtam, y _ventana_ytam.

Referenciado por VISOR_GEOMETRIA::procesar_resize(), VISOR_CAMPO_VECTORIAL::procesar_resize(), y VISOR::procesar_resize().

BOOLEAN CAMARA::procesar_teclado (  EVENTO_GUI *  e  ) 
 

Este metodo recibe un evento de teclado y cambia el estado de la camara.

Es util para la actualizacion de la camara por parte de un usuario humano en aplicaciones interactivas AQUYNZA. Notese que el comportamiento de la camara (su respuesta a eventos de teclado) esta cableada en este metodo.

Este metodo es tan solo un gran `switch`. Los casos del switch estan organi- zados en secciones. Vea bien cada titulo de seccion para entender la estructura del metodo.

Definición en la línea 1100 del archivo camara.C.

References _far_plane, _fov, _modo_proyeccion, _near_plane, _posicion, CAM_PARALELA, CAM_PERSPECTIVA, CAM_STANDARD, CAM_VUELO, imprimir(), EVENTO_GUI::key_code, modo_control, mostrar_etiqueta, VECTOR::x, VECTOR::y, y VECTOR::z.

Referenciado por VISOR_GEOMETRIA::procesar_teclado(), VISOR_CAMPO_VECTORIAL::procesar_teclado(), y VISOR::procesar_teclado().

Here is the call graph for this function:

BOOLEAN CAMARA::proyectar_punto (  VECTOR *  in_P,
double *  out_U,
double *  out_V
) 
 

Dado un punto `*in_P` en coordenadas absolutas, se calcula un punto P', que se encuentra ubicado en el plano de proyección y cuyas coordenadas relativas a dicho plano son (*out_U, *out_V).

Se retorna TRUE si el punto P' se encuentra dentro de la superficie de proyección y FALSE si no.

Por ahora se sigue el siguiente macroalgoritmo (el cual es una "vuelta del bobo"): 1. Se preprocesa la vista, para tener acceso a los vectores para el manejo en álgebra vectorial de la cámara 2. Se calcula un proyector `r` tal que parte del centro de la cámara y se dirige hacia el punto `*in_P` 3. Se calcula la ecuación canónica del plano de proyección 4. Se intersecta el rayo `r` con el plano de proyección, y el resultado se guarda en (`u`, `v`). 5. Se escalan las coordenadas `u`, `v` de tal manera que sean proporcionales a coordenadas en el espacio del viewport de la cámara (para eso se tiene en cuenta a `_ventana_xtam` y `_ventana_ytam`), y el resultado se guarda en (`*out_V`, `*out_U`). 6. Se determina si la coordenada cae dentro o fuera de la superficie de proyección y se retorna TRUE o FALSE.

OJO:

  • Solo se ha considerado la operación para el caso en que la proyección de cámara es perspectiva
  • Este es un método experimental
  • De encontrarse útil, este método debería ser reemplazado por una versión en donde la coordenada resultante se exprese como una simple multiplicación del punto de entrada por una matriz de proyección (como es una proyección planar geométrica, debe poder expresarse mediante una operación de álgebra lineal con una matriz homogénea, que posiblemente es la matriz de proyección de cámara o alguna muy parecida. Las pruebas ejecutadas hasta el momento en esa dirección, han fallado!)

Definición en la línea 334 del archivo camara.C.

References _dir, _fov, _near_plane, _pos, _right, _up, _ventana_xtam, _ventana_ytam, RAYO::direccion, VECTOR::norma(), VECTOR::normalizar(), RAYO::origen, preprocesar_vista(), VECTOR::producto_punto(), VECTOR::x, VECTOR::y, y VECTOR::z.

Here is the call graph for this function:

void CAMARA::set_far_plane (  double  f  ) 
 

Definición en la línea 128 del archivo camara.C.

References _far_plane.

void CAMARA::set_fov (  double  in_nuevo_fov  ) 
 

Definición en la línea 160 del archivo camara.C.

References _fov.

void CAMARA::set_modelo (  int  val  ) 
 

Este metodo activa (con TRUE) o desactiva (con FALSE) la generacion de una representacion grafica de la camara (vea el metodo `pintar_gl`).

Tenga en cuenta que normalmente una camara que se usa para visualizar una escena NO se pinta, y las que se pintan son las demas camaras.

Definición en la línea 717 del archivo camara.C.

References tipo_modelo.

void CAMARA::set_near_plane (  double  f  ) 
 

Definición en la línea 140 del archivo camara.C.

References _near_plane.

void CAMARA::set_orientacion (  QUATERNION  o  ) 
 

Definición en la línea 154 del archivo camara.C.

References _orientacion.

Referenciado por VISOR_GEOMETRIA::init(), y VISOR_CAMPO_VECTORIAL::init().

void CAMARA::set_posicion (  VECTOR  p  ) 
 

Definición en la línea 153 del archivo camara.C.

References _posicion.

Referenciado por VISOR_GEOMETRIA::init(), y VISOR_CAMPO_VECTORIAL::init().

void CAMARA::subbillboard_gl (  int  tam,
int  x,
int  y,
int  dx,
int  dy,
int  cuadre
) 
 

Activa el viewport de manera tal que corresponda a una la celda imaginaria (x,y)-(x+dx, y+dy) dentro de una cuadricula de tam x tam pedazos sobre el cuadro definido por billboard_gl(CAM_CUADRAR_MENOR).

Ademas, cuadre es: < 0 : la cuadricula se corre hacia abajo o hacia la izquierda == 0 : la cuadricula se deja centrada > 0 : lacuadricula se corre hacia arriba o hacia la derecha

Ademas, deja configurada una vista ortogonal por defecto, ideal para trazar primitivas 2D en el intervalo [(-1, -1), (1, 1)]

OJO: El sistema de coordenadas 2D tiene origen en la esquina inferior izquierda

Definición en la línea 848 del archivo camara.C.

References _ventana_xtam, y _ventana_ytam.

Referenciado por VISOR_SENSOR_VECTOR::pintar_gl(), y VISOR_SENSOR_FLOAT::pintar_gl().

Documentación de los datos miembro

BOOLEAN CAMARA::_con_posicion [private]
 

Existen ciertas ocaciones en las cuales una aplicación puede necesitar activar la orientación de una CAMARA sin activar su posicion.

Ejemplos de estas situaciones incluyen la visualización de fondos (i.e. por ejemplos mapas de entornos basados en texturas o fondos de estrellas), en donde se muestra la ilusión de que el fondo no cambia con la translación de la cámara porque está muy lejano, pero si cambia al rotar la cámara. Para lograr dicho efecto, la CAMARA ofrece el método "activar_centro_gl", que coloca en FALSE el valor de ésta variable, que en condiciones normales permanece en TRUE. Nótese que al usuario de esta clase no le interesa tener acceso a ésta variable, sino simplemente usar los métodos `CAMARA::activar_gl` y `CAMARA::activar_centro_gl`. El método se usa para poder distinguir en las múltiples operaciones internas de la CAMARA, cuándo son parte de un tipo de algoritmo u otro.

Definición en la línea 166 del archivo camara.h.

Referenciado por activar_centro_gl(), calcular_matriz_de_proyeccion(), CAMARA(), minmax_visible(), pintar_gl(), y preprocesar_vista().

VECTOR CAMARA::_dir [private]
 

Definición en la línea 179 del archivo camara.h.

Referenciado por activar_povray(), generar_rayo(), preprocesar_vista(), y proyectar_punto().

double CAMARA::_far_plane [private]
 

Distancia al plano lejano del volumen de visualización al centro de proyección de la CAMARA.

Definición en la línea 109 del archivo camara.h.

Referenciado por calcular_matriz_de_proyeccion(), CAMARA(), far_plane(), imprimir(), leer(), minmax_visible(), pintar_volumen_gl(), procesar_teclado(), y set_far_plane().

double CAMARA::_fov [private]
 

Ángulo de visión (apertura)

Definición en la línea 105 del archivo camara.h.

Referenciado por calcular_matriz_de_proyeccion(), CAMARA(), fov(), imprimir(), leer(), minmax_visible(), pintar_volumen_gl(), preprocesar_vista(), procesar_teclado(), proyectar_punto(), y set_fov().

int CAMARA::_modo_proyeccion [private]
 

Una de las `ENUM_TIPOS_PERSPECTIVAS`.

Definición en la línea 112 del archivo camara.h.

Referenciado por calcular_matriz_de_proyeccion(), CAMARA(), imprimir(), leer(), minmax_visible(), pintar_volumen_gl(), y procesar_teclado().

double CAMARA::_near_plane [private]
 

Distancia al plano cercano del volumen de visualización al centro de proyección de la CAMARA.

Definición en la línea 106 del archivo camara.h.

Referenciado por calcular_matriz_de_proyeccion(), CAMARA(), imprimir(), leer(), minmax_visible(), near_plane(), pintar_volumen_gl(), procesar_teclado(), proyectar_punto(), y set_near_plane().

char* CAMARA::_nombre_padre [private]
 

OJO: Esto no es redundante?

Definición en la línea 119 del archivo camara.h.

Referenciado por CAMARA(), leer(), nombre_padre(), y ~CAMARA().

QUATERNION CAMARA::_orientacion [private]
 

Orientación de la CAMARA.

Definición en la línea 104 del archivo camara.h.

Referenciado por calcular_matriz_de_proyeccion(), CAMARA(), consultar_variable(), imprimir(), leer(), minmax_visible(), orientacion(), pintar_gl(), preprocesar_vista(), procesar_mouse(), y set_orientacion().

ENTIDAD* CAMARA::_Padre [private]
 

Una camara puede asociarse a una ENTIDAD!

Definición en la línea 118 del archivo camara.h.

Referenciado por asociar_padre(), calcular_matriz_de_proyeccion(), CAMARA(), minmax_visible(), pintar_gl(), y preprocesar_vista().

VECTOR CAMARA::_pos [private]
 

Definición en la línea 180 del archivo camara.h.

Referenciado por activar_povray(), generar_rayo(), preprocesar_vista(), y proyectar_punto().

VECTOR CAMARA::_posicion [private]
 

Posición de la CAMARA.

Definición en la línea 103 del archivo camara.h.

Referenciado por activar_centro_gl(), calcular_matriz_de_proyeccion(), CAMARA(), consultar_variable(), imprimir(), leer(), minmax_visible(), pintar_gl(), posicion(), preprocesar_vista(), procesar_mouse(), procesar_teclado(), y set_posicion().

VECTOR CAMARA::_right [private]
 

Definición en la línea 178 del archivo camara.h.

Referenciado por activar_povray(), generar_rayo(), preprocesar_vista(), y proyectar_punto().

VECTOR CAMARA::_up [private]
 

Los `VECTOR`es `_up`, `_right`, `_dir` y `_pos` son variables temporales para calculadas dentro del método `CAMARA::preprocesar_vista`, y para uso interno de los demás métodos de la clase.

Caracterizan la ubicación y orientación de la CAMARA, y su relación con el volumen de visualización. Se utilizan para acelerar ciertos cálculos que hacen parte de la creación de una proyección.

Definición en la línea 177 del archivo camara.h.

Referenciado por activar_povray(), generar_rayo(), imprimir(), preprocesar_vista(), y proyectar_punto().

int CAMARA::_ventana_xtam [private]
 

Una `CAMARA` debe saber de qué tamaño es el viewport para el cual está generando una proyección, para poder modificar sus parámetros internos en función del ángulo de vision (`_fov`) y de la actual proporción de ancho/alto del viewport.

Las variables internas `_ventana_xtam` y `_ventana_ytam` representan el tamańo en pixels para el viewport, y son valores que solo pueden ser cambiados por el método `CAMARA::procesar_resize`. Estos dos valores son para uso interno de la clase cámara y no pueden ser consultados (i.e. son una copia de la configuración del viewport, que debe ser administrado por la aplicación que use `CAMARA`s).

Definición en la línea 146 del archivo camara.h.

Referenciado por billboard_gl(), calcular_matriz_de_proyeccion(), CAMARA(), factor_font(), generar_rayo(), minmax_visible(), pintar_volumen_gl(), preprocesar_vista(), procesar_resize(), proyectar_punto(), y subbillboard_gl().

int CAMARA::_ventana_ytam [private]
 

Ver la documentación de `_ventana_xtam`.

Definición en la línea 147 del archivo camara.h.

Referenciado por billboard_gl(), calcular_matriz_de_proyeccion(), CAMARA(), generar_rayo(), minmax_visible(), pintar_volumen_gl(), preprocesar_vista(), procesar_resize(), proyectar_punto(), y subbillboard_gl().

double CAMARA::_zoom_paralelo [private]
 

Usado cuando _modo_proyeccion = CAM_PARALELA, representa un valor en aumentos, que por defecto es 1 y debe ser mayor a EPSILON.

Definición en la línea 113 del archivo camara.h.

COLOR CAMARA::color_etiqueta [private]
 

Usado si `mostrar_etiqueta` es TRUE.

Definición en la línea 126 del archivo camara.h.

Referenciado por billboard_gl(), CAMARA(), y leer().

int CAMARA::modo_control [private]
 

uno de los MODOS_DE_CONTROL_CAMARA

Definición en la línea 130 del archivo camara.h.

Referenciado por CAMARA(), y procesar_teclado().

int CAMARA::modo_seguimiento [private]
 

uno de los MODOS_DE_CAMARA

Definición en la línea 129 del archivo camara.h.

Referenciado por CAMARA().

BOOLEAN CAMARA::mostrar_etiqueta [private]
 

TRUE si el nombre de la cámara se muestra sobre el viewport en la capa "cockpit" (vicera de piloto en transparente).

Definición en la línea 121 del archivo camara.h.

Referenciado por billboard_gl(), CAMARA(), leer(), y procesar_teclado().

int CAMARA::tipo_modelo [private]
 

Para pintar_gl() -> Deberia llamarse "modo".

Definición en la línea 128 del archivo camara.h.

Referenciado por CAMARA(), leer(), modelo(), pintar_gl(), y set_modelo().

double CAMARA::transparencia_etiqueta [private]
 

`mostrar_etiqueta` es TRUE

Definición en la línea 124 del archivo camara.h.

Referenciado por billboard_gl(), CAMARA(), y leer().

La documentación para esta clase fué generada a partir de los siguientes archivos:
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.