camara.C

Ir a la documentación de este archivo.

//===========================================================================
//= camara.C                                            Desde julio de 1998 =
//=-------------------------------------------------------------------------=
//= Definiciones de la clase CAMARA. Este modulo esta dividido en las si-   =
//= guientes secciones:                                                     =
//=   - Operaciones basicas                                                 =
//=   - Operaciones de visualizacion                                        =
//=   - Operaciones de soporte al manejo GUI                                =
//=   - Operaciones de persistencia                                         =
//=-------------------------------------------------------------------------=
//= 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"  // Incluir antes que nada, en ese modulo se definen 
                       // aspectos importantes para la portabilidad del sistema

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "toolkits/entorno/camara.h"
#include "matriz4.h"

#ifdef GLTT_ENABLED
    #include "toolkits/util/gl_fonts.h"
#endif

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

static VECTOR obj, arr;

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

#define DISMINUIR(n)                            \
    if ( (n) > 10000000 + EPSILON ) (n) /= 2;           \
    else if ( (n) > 1000000 + EPSILON ) (n) -= 1000000; \
    else if ( (n) > 100000 + EPSILON ) (n) -= 100000;   \
    else if ( (n) > 10000 + EPSILON ) (n) -= 10000;     \
    else if ( (n) > 1000 + EPSILON ) (n) -= 1000;               \
    else if ( (n) > 100 + EPSILON ) (n) -= 100;         \
    else if ( (n) > 10 + EPSILON ) (n) -= 10;           \
    else if ( (n) > 1 + EPSILON ) (n) -= 1;             \
    else if ( (n) > 0.1 + EPSILON ) (n) -= 0.1;         \
    else if ( (n) > 0.01 + EPSILON ) (n) -= 0.01;               \
    else if ( (n) > 0.001 + EPSILON ) (n) -= 0.001;     \
    else if ( (n) > 0.0001 + EPSILON ) (n) -= 0.0001;   \
    else (n) = 0.0001;

#define AUMENTAR(n)                                     \
    if ( (n) < 0.001 ) (n) += 0.0001;                   \
    else if ( (n) < 0.01 ) (n) += 0.001;                \
    else if ( (n) < 0.1 - EPSILON ) (n) += 0.01;        \
    else if ( (n) < 1 - EPSILON ) (n) += 0.1;           \
    else if ( (n) < 10 - EPSILON ) (n) += 1;            \
    else if ( (n) < 100 - EPSILON ) (n) += 10;          \
    else if ( (n) < 1000 - EPSILON ) (n) += 100;        \
    else if ( (n) < 10000 - EPSILON ) (n) += 1000;      \
    else if ( (n) < 100000 - EPSILON ) (n) += 10000;    \
    else if ( (n) < 1000000 - EPSILON ) (n) += 100000;  \
    else if ( (n) < 10000000 - EPSILON ) (n) *= 2;      \
    else (n) = 10000000;

//===========================================================================
//= CLASE CAMARA                                                            =
//===========================================================================

//= OPERACIONES BASICAS =====================================================

CAMARA::CAMARA()
{
    // Posicion por defecto
    _posicion.x = 2.5;
    _posicion.y = 0.5;
    _posicion.z = 0.5;

    // Orientacion por defecto
    float magnitud = 0;
    VECTOR k(0, 0, 1);
    _orientacion.importar_angulo_eje(magnitud, k);

    // Las propiedades de la etiqueta
    mostrar_etiqueta = FALSE;
    transparencia_etiqueta = 1.0;
    color_etiqueta.r = 1;
    color_etiqueta.g = 1;
    color_etiqueta.b = 0;

    // Las demas vainas
    _ventana_xtam = _ventana_ytam = 200;
    _fov = 60.0;
    modo_seguimiento = CAM_GLOBAL;
    modo_control = CAM_STANDARD;
    _modo_proyeccion = CAM_PERSPECTIVA;
    _near_plane = 0.05;
    _far_plane = 100;  // OJO: Esto no es igual a 1? (al parecer no!)

    _nombre_padre = NULL;
    _Padre = NULL;

    _con_posicion = TRUE;
    tipo_modelo = 0;
}

CAMARA::~CAMARA()
{
    if ( _nombre_padre ) delete _nombre_padre;
}

void
CAMARA::set_far_plane(double f)
{
    _far_plane = f;
}

double
CAMARA::far_plane(void)
{
    return _far_plane;
}

void
CAMARA::set_near_plane(double f)
{
    _near_plane = f;
}

double
CAMARA::near_plane(void)
{
    return _near_plane;
}

VECTOR CAMARA::posicion(void) { return _posicion; }
QUATERNION CAMARA::orientacion(void) { return _orientacion; }
void CAMARA::set_posicion(VECTOR p) { _posicion = p; }
void CAMARA::set_orientacion(QUATERNION o) { _orientacion = o; }
char * CAMARA::nombre_padre(void) { return _nombre_padre; }
void CAMARA::asociar_padre(ENTIDAD *p) { _Padre = p; }
double CAMARA::fov(void) { return _fov; };

void
CAMARA::set_fov(double in_nuevo_fov)
{
    if ( in_nuevo_fov > EPSILON && in_nuevo_fov < 180.0 ) {
    _fov = in_nuevo_fov;
    }
}

static QUATERNION TMP_quaternion;

BOOLEAN
CAMARA::consultar_variable(const char *nombre_variable, int &tipo, void **ref)
{
    if ( strcmp(nombre_variable, "posicion") == 0 ) {
        tipo = T_VECTOR;    (*ref) = &_posicion;    return TRUE;
      }
      if ( strcmp(nombre_variable, "orientacion") == 0 ) {
        // OJO: Esto toca redefinirlo! Es un la orientacion absoluta!
        TMP_quaternion = _orientacion; // = orientacion_absoluta();
        tipo = T_QUATERNION;(*ref) = &TMP_quaternion;    return TRUE;
      }
    ;
    return FALSE;
}

BOOLEAN
CAMARA::minmax_visible(VECTOR esquinas[8])
{
    //- Actualice la posicion y orientacion de la camara --------------------
    MATRIZ_4x4 R, T1, T2, R1, R2;
    QUATERNION p_ori;
    VECTOR p_pos(0, 0, 0);
    void *interfaz;
    int tipo;

    if ( _Padre && _Padre->consultar_variable("posicion", tipo, &interfaz) &&
         _con_posicion ) {
        if ( tipo == T_VECTOR ) p_pos = (*(VECTOR *)interfaz);
    }

    T1.translacion(_posicion.x, _posicion.y, _posicion.z);
    T2.translacion(p_pos.x, p_pos.y, p_pos.z);

    R1.importar_quaternion(_orientacion);

    if ( _Padre &&
         _Padre->consultar_variable("orientacion_absoluta", tipo, &interfaz) &&
         tipo == T_QUATERNION ) {
        p_ori = (*(QUATERNION *)interfaz);
        R2.importar_quaternion(p_ori);
        R = T2 * (R2 * (T1 * R1));
      }
      else {
        R = T2 * (T1 * R1);
    }

    //- Calcule los extremos del volumen de visualizacion -------------------
    double xn = 1, yn = 1;
    double xf = 1, yf = 1;

    if ( _modo_proyeccion != CAM_PARALELA ) {
        yn = 2 * _near_plane * tan(DEG2RAD(_fov) / 2);
        xn = yn * ((double)_ventana_xtam/(double)_ventana_ytam);
    }
    else {
        if ( _ventana_xtam > _ventana_ytam ) {
            xn = 1;
            yn = (double)_ventana_ytam / (double)_ventana_xtam;
          }
          else {
            xn = (double)_ventana_xtam / (double)_ventana_ytam;
            yn = 1;
        }
    }

    xf = xn;
    yf = yn;
    if ( _modo_proyeccion != CAM_PARALELA ) {
        yf = 2 * _far_plane * tan(DEG2RAD(_fov) / 2);
        xf = yf * ((double)_ventana_xtam/(double)_ventana_ytam);
    }

    //- Calcule las ecuaciones de los 6 planos a partir de los extremos -----
    VECTOR normales_planos[6];
    VECTOR puntos_planos[6];
    VECTOR p1, p2, p3;
    int i;

    for ( i = 0; i < 6; i++ ) {
        switch ( i ) {
          case 0:
            p1.x = _near_plane; p1.y =  xn/2; p1.z = -yn/2;
            p2.x = _near_plane; p2.y = -xn/2; p2.z =  yn/2;
            p3.x = _near_plane; p3.y = -xn/2; p3.z = -yn/2;
            break;
          case 1:
            p1.x = _near_plane; p1.y =  xn/2; p1.z =  yn/2;
            p2.x = _far_plane;  p2.y =  xf/2; p2.z =  yf/2;
            p3.x = _near_plane; p3.y = -xn/2; p3.z =  yn/2;
            break;
          case 2:
            p1.x = _near_plane; p1.y =  xn/2; p1.z = -yn/2;
            p2.x = _far_plane;  p2.y =  xf/2; p2.z = -yf/2;
            p3.x = _near_plane; p3.y =  xn/2; p3.z =  yn/2;
            break;
          case 3:
            p1.x = _near_plane; p1.y = -xn/2; p1.z = -yn/2;
            p2.x = _far_plane;  p2.y = -xf/2; p2.z = -yf/2;
            p3.x = _near_plane; p3.y =  xn/2; p3.z = -yn/2;
            break;
          case 4:
            p1.x = _near_plane; p1.y = -xn/2; p1.z = -yn/2;
            p2.x = _near_plane; p2.y = -xn/2; p2.z =  yn/2;
            p3.x = _far_plane;  p3.y = -xf/2; p3.z = -yf/2;
            break;
          case 5:
            p1.x = _far_plane;  p1.y = -xf/2; p1.z =  yf/2;
            p2.x = _far_plane;  p2.y =  xf/2; p2.z = -yf/2;
            p3.x = _far_plane;  p3.y = -xf/2; p3.z = -yf/2;
            break;
          default: break;
        }
        p1 = R * p1;
        p2 = R * p2;
        p3 = R * p3;

        normales_planos[i] = ((p2 - p1).producto_cruz(p3 - p1));
        normales_planos[i].normalizar();
        puntos_planos[i] = p1;
    }

    //- A partir de las ecuaciones de planos determino si esta afuera... ----
    int j;
    BOOLEAN fuera;
    VECTOR p;

    for ( i = 0; i < 6; i++ ) {
        fuera = TRUE;
        for ( j = 0; j < 8; j++ ) {
            p = esquinas[j] - puntos_planos[i];
            if ( p.producto_punto(normales_planos[i]) > 0 ) {
                fuera = FALSE;
                break;
            }
        }
        if ( fuera ) return FALSE;
    }

    return TRUE;
}

BOOLEAN
CAMARA::proyectar_punto(VECTOR *in_P, double *out_U, double *out_V)
{
    //- 1. Preprocesar vista ------------------------------------------------
    preprocesar_vista();
    (*out_U) = 0;
    (*out_V) = 0;

    double factor_fov = ((double)_ventana_xtam/(double)_ventana_ytam);
    double machete = 1/tan(DEG2RAD(_fov/2));

    _up.normalizar();
    _up = _up * machete;
    _right.normalizar();
    _right = _right * machete / factor_fov;

    //- 2. Calcular el proyector que pasa por `*in_P` -----------------------
    RAYO r;

    r.origen = _pos;
    r.direccion = ((*in_P) - _pos);
    if ( r.direccion.norma() < EPSILON ) {
    return FALSE;
    }
    r.direccion.normalizar();

    //- 3. Calcular el plano de proyeccion ----------------------------------
    double A, B, C, D;
    VECTOR normal = _dir*(-1);

    normal.normalizar();
    A = normal.x;
    B = normal.y;
    C = normal.z;
    D = -A*(_pos.x+A/2) - B*(_pos.y+B/2) - C*(_pos.z+C/2);

    // El plano es: Ax + By + Cz + D = 0

    //- 4. Calcular P' en coordenadas globales XYZ --------------------------
    VECTOR p_prima;
    double t;

    t = (A*r.origen.x + B*r.origen.y + C*r.origen.z + D) / 
     (A*r.direccion.x + B*r.direccion.y + C*r.direccion.z);

    if ( t < EPSILON ) {
    return FALSE;
    }

    p_prima = r.origen + r.direccion*t; // Hasta aqui, p_prima esta OK

    //- 5. ------------------------------------------------------------------
    VECTOR centro;

    centro = _dir;
    centro.normalizar();
    centro = centro*_near_plane + _pos;
    p_prima = p_prima - centro;

    // Notese que la base u,v es _right,_up
    (*out_U) = (p_prima.producto_punto(_right)+0.5);
    (*out_V) = (-p_prima.producto_punto(_up)+0.5);

    // OJO: Esta manera de hacer recorte de lineas seguramente es
    //      incorrecta!
    if ( (*out_U) < -1 || (*out_U) > 2 || 
         (*out_V) < -1 || (*out_V) > 2 ) {
    return FALSE;
    }

    (*out_U) *= _ventana_xtam;
    (*out_V) *= _ventana_ytam;

    //-----------------------------------------------------------------------

    return TRUE;
}

void
CAMARA::preprocesar_vista(void)
{
    //- Actualice la posicion y orientacion de la camara --------------------
    MATRIZ_4x4 R, T1, T2, R1, R2;
    QUATERNION p_ori;
    VECTOR p_pos(0, 0, 0);
    void *interfaz;
    int tipo;

    if ( _Padre && _Padre->consultar_variable("posicion", tipo, &interfaz) &&
         _con_posicion ) {
        if ( tipo == T_VECTOR ) p_pos = (*(VECTOR *)interfaz);
    }

    // OJO:  Sera posible mejorar esto? (i.e. usar menos transformaciones o
    //       usar directamente quaternions?)
    T1.translacion(-_posicion.x, -_posicion.y, -_posicion.z);
    T2.translacion(-p_pos.x, -p_pos.y, -p_pos.z);

    R1.importar_quaternion(_orientacion);

    if ( _Padre &&
         _Padre->consultar_variable("orientacion_absoluta", tipo, &interfaz) &&
         tipo == T_QUATERNION ) {
        p_ori = (*(QUATERNION *)interfaz);
        R2.importar_quaternion(p_ori);
        R = R1.inversa() * (T1 * (R2.inversa() * T2));
      }
      else {
        R = R1.inversa() * (T1 * T2);
    }

    //----------------------------------------------------------------------
    MATRIZ_4x4 R_i = R.inversa();
    double factor_fov = ((double)_ventana_xtam/(double)_ventana_ytam);

    _right.x = _right.z = 0;
    _right.y = -factor_fov * tan(DEG2RAD(_fov/2));
    _up.x = _up.y = 0;
    _up.z = tan(DEG2RAD(_fov/2));
    _dir.x = 0.5; // OJO: Porque 0.5 y no 1.0?
    _dir.y = _dir.z = 0;
    _pos = _posicion + p_pos;
    _dir = R_i * _dir;
    _up = R_i * _up;
    _right = R_i * _right;
}

MATRIZ_4x4
CAMARA::calcular_matriz_de_proyeccion(int modo_stereo)
{
    //- Actualice la proyeccion ---------------------------------------------
    // OJO: Toca entender bien como belcebures es que funciona la matriz de
    //      proyeccion en OpenGL! Debe repasarse el esquema de transformacion
    //      de vertices (i.e. el capitulo 2.10 de la especificacion de
    //      OpenGL 1.1)... y por supuesto... lo basico de esas matrices!
    // No sera bueno especificar directamente el glDepthRange y jugar de
    // alguna otra manera mas directa con la matriz de proyeccion?
    // Tenga en cuenta que _near_plane y _far_plane deben estar entre 0 y 1 (?)
    double izq, der, arr, aba, aspecto;
    MATRIZ_4x4 P;

    switch ( _modo_proyeccion ) {
      case CAM_PARALELA:
        P.ortho(-1, 1, -1, 1, _near_plane, _far_plane);
        break;
      case CAM_PERSPECTIVA: default:
        // Equivale a gluPerspective(_fov,
        //     (double)_ventana_xtam/(double)_ventana_ytam, 
        //     _near_plane, _far_plane);
        aspecto = (double)_ventana_xtam/(double)_ventana_ytam;
        arr = _near_plane * tan(_fov * PI / 360.0);
        aba = -arr;
        izq = aspecto * aba;
        der = aspecto * arr;
        P.frustum(izq, der, aba, arr, _near_plane, _far_plane);
        break;
    }

    //- Actualice la posicion y orientacion de la camara --------------------
    MATRIZ_4x4 R, T1, T2, R1, R_adic2, R_adic1, R2, Tstereo;
    QUATERNION p_ori;
    VECTOR p_pos(0, 0, 0), pstereo;
    void *interfaz;
    int tipo;
    double factor_distancia_entre_ojos = 0.04;

    if ( _Padre && _Padre->consultar_variable("posicion", tipo, &interfaz) &&
         _con_posicion ) {
        if ( tipo == T_VECTOR ) p_pos = (*(VECTOR *)interfaz);
    }

    // Nota: la rotacion adicional `R_adic1*R_adic2` convierte la orientacion
    //       por defecto AQUYNZA (una camara en el origen mirando en la
    //       direccion <1, 0, 0> con vector arriba <0, 0, 1>) a la orientacion
    //       por defecto OpenGL (una camara mirando hacia el origen, desde
    //       <0, 0, 1> con arriba <0, 1, 0>).
    // OJO:  Sera posible mejorar esto? (i.e. usar menos transformaciones o
    //       usar directamente quaternions?)

    R1.importar_quaternion(_orientacion);

    T1.translacion(-_posicion.x, -_posicion.y, -_posicion.z);
    T2.translacion(-p_pos.x, -p_pos.y, -p_pos.z);

    R_adic2.rotacion_eje(DEG2RAD(90), 0, 0, 1);
    R_adic1.rotacion_eje(DEG2RAD(-90), 1, 0, 0);

    if ( _Padre &&
         _Padre->consultar_variable("orientacion_absoluta", tipo, &interfaz) &&
         tipo == T_QUATERNION ) {
        p_ori = (*(QUATERNION *)interfaz);
        R2.importar_quaternion(p_ori);
        R = R1.inversa() * (T1 * (R2.inversa() * T2));
      }
      else {
        R = R1.inversa() * (T1 * T2);
    }

    R = R_adic1 * (R_adic2 * R); // Rotacion adicional

    if ( modo_stereo == 1 ) {
        pstereo.x = -R.M[0][0] * factor_distancia_entre_ojos;
        pstereo.y = -R.M[0][1] * factor_distancia_entre_ojos;
        pstereo.z = -R.M[0][2] * factor_distancia_entre_ojos;
        Tstereo.translacion(pstereo.x, pstereo.y, pstereo.z);
        R = R * Tstereo;
    }
    if ( modo_stereo == 2 ) {
        pstereo.x = R.M[0][0] * factor_distancia_entre_ojos;
        pstereo.y = R.M[0][1] * factor_distancia_entre_ojos;
        pstereo.z = R.M[0][2] * factor_distancia_entre_ojos;
        Tstereo.translacion(pstereo.x, pstereo.y, pstereo.z);
        R = R * Tstereo;
    }

    R = P * R;
    return R;
}

//= OPERACIONES DE VISUALIZACION (REPRESENTACION GEOMETRICA) ================

#ifdef GL_ENABLED

void
CAMARA::pintar_base_gl(void)
{
    VECTOR o(0, 0, 0);
    VECTOR i(1, 0, 0);
    VECTOR j(0, 1, 0);
    VECTOR k(0, 0, 1);

    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    glDisable(GL_LIGHTING);
    glDisable(GL_TEXTURE_2D);
    glShadeModel(GL_FLAT);
    glColor3f(1, 0, 0);    PINTAR_VECTOR_GL(o, i, 0.05, 0.3, 0.1);
    glColor3f(0, 1, 0);    PINTAR_VECTOR_GL(o, j, 0.05, 0.3, 0.1);
    glColor3f(0, 0, 1);    PINTAR_VECTOR_GL(o, k, 0.05, 0.3, 0.1);
}

void
CAMARA::pintar_volumen_gl(void)
{
//    printf("[!]"); fflush(stdout);

    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    glDisable(GL_LIGHTING);
    glDisable(GL_TEXTURE_2D);
    glShadeModel(GL_FLAT);

    //- Calcule los extremos del volumen de visualizacion -------------------
    double xn = 1, yn = 1;
    double xf = 1, yf = 1;

    if ( _modo_proyeccion != CAM_PARALELA ) {
        yn = 2 * _near_plane * tan(DEG2RAD(_fov) / 2);
        xn = yn * ((double)_ventana_xtam/(double)_ventana_ytam);
    }
    else {
        if ( _ventana_xtam > _ventana_ytam ) {
            xn = 1;
            yn = (double)_ventana_ytam / (double)_ventana_xtam;
          }
          else {
            xn = (double)_ventana_xtam / (double)_ventana_ytam;
            yn = 1;
        }
    }

    xf = xn;
    yf = yn;
    if ( _modo_proyeccion != CAM_PARALELA ) {
        yf = 2 * _far_plane * tan(DEG2RAD(_fov) / 2);
        xf = yf * ((double)_ventana_xtam/(double)_ventana_ytam);
    }

    //- Genere las primitivas que muestran el volumen de visualizacion ------
    glColor3f(1, 0.5, 0.5);   // Origen de la camara
    glBegin(GL_POINTS);
        glVertex3d(0, 0, 0);
    glEnd();

    glDisable(GL_LIGHTING);
    glColor3f(0, 1, 1);       // Plano de proyeccion
    glBegin(GL_LINE_LOOP);
        glVertex3d(_near_plane, -xn/2, -yn/2);
        glVertex3d(_near_plane, xn/2, -yn/2);
        glVertex3d(_near_plane, xn/2, yn/2);
        glVertex3d(_near_plane, -xn/2, yn/2);
    glEnd();
    glBegin(GL_LINES);
        glVertex3d(_near_plane, -xn/10, -yn/10);
        glVertex3d(_near_plane, xn/10, yn/10);
        glVertex3d(_near_plane, xn/10, -yn/10);
        glVertex3d(_near_plane, -xn/10, yn/10);
        glVertex3d(_near_plane, -xn/10, yn/2);
        glVertex3d(_near_plane, 0, yn/2+yn/10);
        glVertex3d(_near_plane, 0, yn/2+yn/10);
        glVertex3d(_near_plane, xn/10, yn/2);
    glEnd();

    glColor3f(0, 1, 1);       // Plano lejano
    glBegin(GL_LINE_LOOP);
        glVertex3d(_far_plane, -xf/2, -yf/2);
        glVertex3d(_far_plane, xf/2, -yf/2);
        glVertex3d(_far_plane, xf/2, yf/2);
        glVertex3d(_far_plane, -xf/2, yf/2);
    glEnd();
    glBegin(GL_LINES);
        glVertex3d(_far_plane, -xf/10, -yf/10);
        glVertex3d(_far_plane, xf/10, yf/10);
        glVertex3d(_far_plane, xf/10, -yf/10);
        glVertex3d(_far_plane, -xf/10, yf/10);
        glVertex3d(_far_plane, -xf/10, yf/2);
        glVertex3d(_far_plane, 0, yf/2+yf/10);
        glVertex3d(_far_plane, 0, yf/2+yf/10);
        glVertex3d(_far_plane, xf/10, yf/2);
    glEnd();

    glBegin(GL_LINES);  // Lineas de los bordes
        glVertex3d(_near_plane, -xn/2, -yn/2);
        glVertex3d(_far_plane, -xf/2, -yf/2);
        glVertex3d(_near_plane, xn/2, -yn/2);
        glVertex3d(_far_plane, xf/2, -yf/2);
        glVertex3d(_near_plane, xn/2, yn/2);
        glVertex3d(_far_plane, xf/2, yf/2);
        glVertex3d(_near_plane, -xn/2, yn/2);
        glVertex3d(_far_plane, -xf/2, yf/2);
    glEnd();
}

void
CAMARA::set_modelo(int val)
{
    tipo_modelo = val;
}

int
CAMARA::modelo(void)
{
    return tipo_modelo;
}

void
CAMARA::pintar_gl(void)
{
    if ( !tipo_modelo ) return;

    //- Actualice la posicion y orientacion de la camara --------------------
    MATRIZ_4x4 R, T1, T2, R1, R2;
    QUATERNION p_ori;
    VECTOR p_pos(0, 0, 0);
    void *interfaz;
    int tipo;

    if ( _Padre && _Padre->consultar_variable("posicion", tipo, &interfaz) &&
         _con_posicion ) {
        if ( tipo == T_VECTOR ) p_pos = (*(VECTOR *)interfaz);
    }

    T1.translacion(_posicion.x, _posicion.y, _posicion.z);
    T2.translacion(p_pos.x, p_pos.y, p_pos.z);

    R1.importar_quaternion(_orientacion);

    if ( _Padre &&
         _Padre->consultar_variable("orientacion_absoluta", tipo, &interfaz) &&
         tipo == T_QUATERNION ) {
        p_ori = (*(QUATERNION *)interfaz);
        R2.importar_quaternion(p_ori);
        R = T2 * (R2 * (T1 * R1));
      }
      else {
        R = T2 * (T1 * R1);
    }

    //-----------------------------------------------------------------------
    glPushMatrix();
    R.cargar_gl(); 
    switch ( tipo_modelo ) {
      case 1: pintar_base_gl(); break;
      case 2: default: pintar_volumen_gl();
    }
    glPopMatrix();
}

#endif // GL_ENABLED

//= OPERACIONES DE VISUALIZACION (ACTIVACION) ===============================

#ifdef GL_ENABLED

void
CAMARA::activar_gl(int modo_stereo)
{
    MATRIZ_4x4 R;

    //- En esta funcion se altera la projeccion OpenGL... -------------------
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    R = calcular_matriz_de_proyeccion(modo_stereo);
    R.cargar_gl(); // Notese que NO se usa gluLookat, pero se hace lo mismo!

//#define TEMPORAL 1
#ifdef TEMPORAL
    MATRIZ_4x4 T;

    T.importar_gl();
    T.imprimir();
#endif

    //- ... y el resto de AQUYNZA solo toca el modelo! ----------------------
    glMatrixMode(GL_MODELVIEW);
}

void
CAMARA::activar_centro_gl(void)
{
    VECTOR p = _posicion;

    _posicion.x = _posicion.y = _posicion.z = 0;
    _con_posicion = FALSE;
    activar_gl();
    _con_posicion = TRUE;
    _posicion = p;
}

void
CAMARA::subbillboard_gl(int tam, int x, int y, int dx, int dy, int cuadre)
{
    int x_tam, y_tam, delta_x = 0, delta_y = 0, ancho_cuadrito, alto_cuadrito;

    if ( _ventana_xtam < _ventana_ytam ) {
        if ( cuadre == 0 ) delta_y = (_ventana_ytam - _ventana_xtam)/2;
        if ( cuadre > 0 ) delta_y = _ventana_ytam - _ventana_xtam;
        x_tam = y_tam = _ventana_xtam;
      }
      else {
        if ( cuadre == 0 ) delta_x = (_ventana_xtam - _ventana_ytam)/2;
        if ( cuadre > 0 ) delta_x = _ventana_xtam - _ventana_ytam;
        x_tam = y_tam = _ventana_ytam;
    }
    ancho_cuadrito = x_tam/tam;
    alto_cuadrito = y_tam/tam;

    glViewport(delta_x + x*ancho_cuadrito, delta_y + y*alto_cuadrito,
               dx*ancho_cuadrito - 1, dy*alto_cuadrito - 1);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

double
CAMARA::factor_font(void)
{
    return 1/(6.25*_ventana_xtam);
}

void
CAMARA::billboard_gl(int tipo)
{
    //- Pinte la etiqueta en el billboard -----------------------------------
  #ifndef GLTT_ENABLED
    static BOOLEAN advertido = FALSE;
    if ( mostrar_etiqueta && !advertido ) {
        fprintf(stderr, "<CAMARA> Warning: tengo la etiqueta %s\n"
               "pero no se puede mostrar por que AQUYNZA se compilo sin la\n"
               "libreria libgltt.\n", nombre());
        fflush(stderr);
        advertido = TRUE;
    }
  #endif
  #ifdef GLTT_ENABLED
    static FTFace *font = NULL;
    static GLTTFont* vector_font = NULL;
    int llx, lly, urx, ury;
    float factor = (float)(factor_font());

    if ( mostrar_etiqueta ) {
        //- Preparativos OpenGL -
        glViewport(0, _ventana_ytam - _ventana_xtam, _ventana_xtam, _ventana_xtam);
        glMatrixMode(GL_PROJECTION);    glLoadIdentity();
        glMatrixMode(GL_MODELVIEW);     glLoadIdentity();
        glDisable(GL_LIGHTING);         glDisable(GL_DEPTH_TEST);

        //- Inicializacion del raster de letras -
        font = chequear_fuente("./etc/fonts/crystal.ttf");
        if ( !font ) {
            fprintf(stderr,
                "<CAMARA> - Error fatal: No encuentro una truetype font!\n");
            fflush(stderr);
            exit(1);
        }
        if ( !vector_font ) {
            vector_font = new GLTTFont(font);
        }
        // OJO: Esto deberia hacerce una vez por vista?
        static int num_vistas = 2;
        if ( num_vistas > 0 ) {
            if ( !vector_font->create(150) ) {
                fprintf(stderr,"<CAMARA> ERROR fatal: "
                    "no puedo crear una fuente GLTT");
                fflush(stderr);
                exit(1);
            }
            num_vistas--;
        }

        //---
        ACTIVAR_TRANSPARENCIA(transparencia_etiqueta);

        //- Generacion de primitivas para la letra y el cuadro -
        vector_font->getBBox(nombre(), llx, lly, urx, ury);
        double dy = ((double)ury) * factor;

        glColor4d(color_etiqueta.r, color_etiqueta.g, color_etiqueta.b,
                  (double)transparencia_etiqueta);
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // Pinta borde
        glRectd(-0.99, 0.99 - 60*factor - dy*1.2, 0.99, 0.99);

        glTranslatef(-((float)urx/2)*factor,
                     0.99f - 40*factor - (float)dy, 0.0f);
        glScalef(factor, factor, factor);

        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // Pinta etiqueta
        vector_font->output(nombre());

        glDisable(GL_BLEND);
    }
  #endif

    //- Programe el estado descrito en la documentacion del metodo ----------
    int delta;

    switch ( tipo ) {
      case CAM_NO_CUADRAR:
        glViewport(0, 0, _ventana_xtam, _ventana_ytam);
        break;
      case CAM_CUADRAR_X:
        delta = (_ventana_ytam - _ventana_xtam)/2;
        glViewport(0, delta, _ventana_xtam, _ventana_xtam);
        break;
      case CAM_CUADRAR_Y:
        delta = (_ventana_xtam - _ventana_ytam)/2;
        glViewport(delta, 0, _ventana_ytam, _ventana_ytam);
        break;
      case CAM_CUADRAR_MENOR: default:
        if ( _ventana_xtam < _ventana_ytam ) {
            delta = (_ventana_ytam - _ventana_xtam)/2;
            glViewport(0, delta, _ventana_xtam, _ventana_xtam);
          }
          else {
            delta = (_ventana_xtam - _ventana_ytam)/2;
            glViewport(delta, 0, _ventana_ytam, _ventana_ytam);
        }
        break;
    }
    glMatrixMode(GL_PROJECTION);    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);     glLoadIdentity();
}
#endif // GL_ENABLED

void
CAMARA::activar_povray(FILE *fd)
{
    preprocesar_vista();

    // OJO: El orden es importante, NO reorganice los parametros!
    fprintf(fd,
"\n//- Especificacion de la camara ----------------------------------------\n"
        "camera {\n"
        "    location <%f, %f, %f>\n"
        "    direction <%f, %f, %f>\n"
        "    up <%f, %f, %f>\n"
        "    right <%f, %f, %f>\n"
        "}\n",
        _pos.x, _pos.y, _pos.z,
        _dir.x, _dir.y, _dir.z,
        _up.x, _up.y, _up.z,
        _right.x, _right.y, _right.z // OJO: .y negado!
    );

}

//= OPERACIONES DE SOPORTE AL MANEJO GUI ====================================

void
CAMARA::imprimir(void)
{
    double yaw, pitch, roll;
    MATRIZ_4x4 R;
    float h, m, s, gg, mm, ss;

    R.importar_quaternion(_orientacion);
    R.exportar_angulos_euler(&yaw, &pitch, &roll);
    clrscr();


    printf("<CAMARA \"%s\">:\n", nombre());

    if ( _modo_proyeccion == CAM_PERSPECTIVA ) {
        printf("  - Camara en modo de proyeccion PERSPECTIVA\n");
      }
      else if ( _modo_proyeccion == CAM_PARALELA ) {
        printf("  - Camara en modo de proyeccion PARALELA\n");
      }
      else {
        printf("  - Camara en modo de proyeccion DESCONOCIDO\n");
      }
    ;

    printf("  - posision(x, y, z) = <%.2f, %.2f, %.2f>\n"
           "  - orientacion(yaw, pitch, roll) = <%.2f, %.2f, %.2f> (en grados)\n",
    _posicion.x, _posicion.y, _posicion.z,
        RAD2DEG(yaw), RAD2DEG(pitch), RAD2DEG(roll));

    //if ( _fov <= 10 ) {
        DEG2hms(RAD2DEG(yaw), &h, &m, &s);
        DEG2gms(RAD2DEG(pitch), &gg, &mm, &ss);
        printf(
         "    . Orientacion precisa: RA<%2.0f:%2.0f:%.2f> DEC<%3.0f:%2.0f:%.2f>\n",
            h, m, s, gg, mm, ss);
    //}

    preprocesar_vista();
    printf("    . Vector UP = <%.2f, %.2f, %.2f>\n", 
       _up.x, _up.y, _up.z);

    printf("  - fov = %.2f\n"
       "  - _near_plane = %.4f\n"
       "  - _far_plane = %.4f\n",
        _fov, _near_plane, _far_plane);

    fflush(stdout);
}

BOOLEAN
CAMARA::procesar_teclado(EVENTO_GUI *e)
{
    double yaw, pitch, roll;
    double inc;
    MATRIZ_4x4 R;

#define INICIO_EULER() \
    R.importar_quaternion(_orientacion); \
    R.exportar_angulos_euler(&yaw, &pitch, &roll);

#define FIN_EULER() \
    R.rotacion_angulos_euler(yaw, pitch, roll); \
    _orientacion = R.exportar_quaternion(); \
    break;

    // Defino el incremento angular en funcion del fov
    if ( _fov > 90 ) inc = DEG2RAD(10);
    else if ( _fov > 45 ) inc = DEG2RAD(5);
    else if ( _fov > 15 ) inc = DEG2RAD(2.5);
    else if ( _fov > 5 ) inc = DEG2RAD(1);
    else inc = DEG2RAD(0.1);

    switch( e->key_code ) {
//- Comportamiento pseudo-avion (modificacion por angulos Euler) ------------
  case JK_RIGHT:    INICIO_EULER();
    yaw -= inc;
    while ( yaw < DEG2RAD(0) ) yaw += DEG2RAD(360);
    FIN_EULER();
  case JK_LEFT:    INICIO_EULER();
    yaw += inc;
    while ( yaw >= DEG2RAD(360) ) yaw -= DEG2RAD(360);
    FIN_EULER();
  case JK_s:    INICIO_EULER();
    roll += DEG2RAD(5);
    while ( roll > DEG2RAD(360) ) roll -= DEG2RAD(360);
    FIN_EULER();
  case JK_S:    INICIO_EULER();
    roll -= DEG2RAD(5);
    while ( roll < 0 ) roll += DEG2RAD(360);
    FIN_EULER();
  case JK_UP:    INICIO_EULER();
    pitch -= inc;
    if ( pitch < DEG2RAD(-90) ) pitch = DEG2RAD(-90);
    FIN_EULER();
  case JK_DOWN:    INICIO_EULER();
    pitch += inc;
    if ( pitch > DEG2RAD(90) ) pitch = DEG2RAD(90);
    FIN_EULER();

//---------------------------------------------------------------------------
  case JK_x:        _posicion.x -= 0.25; break;
  case JK_X:        _posicion.x += 0.25; break;
  case JK_y:        _posicion.y -= 0.25; break;
  case JK_Y:        _posicion.y += 0.25; break;
  case JK_z:        _posicion.z -= 0.25; break;
  case JK_Z:        _posicion.z += 0.25; break;

  case JK_A:
    if ( _fov < 0.1 - EPSILON ) _fov += 0.1;
    else if ( _fov < 1 - EPSILON ) _fov++;
    else if ( _fov < 175 - EPSILON ) _fov += 5;
    break;
  case JK_a:
    if ( _fov > 5 + EPSILON ) _fov -= 5;
    else if ( _fov > 1 + EPSILON  ) _fov--;
    else if ( _fov > 0.1 + EPSILON  ) _fov -= 0.1;
    break;

  case JK_p: // Rote el modo de proyeccion
    switch ( _modo_proyeccion ) {
      case CAM_PERSPECTIVA: _modo_proyeccion = CAM_PARALELA; break;
      default: _modo_proyeccion = CAM_PERSPECTIVA; break;
    }
    break;

  case JK_e: // Active/desactive las etiquetas
    if ( mostrar_etiqueta ) {
        mostrar_etiqueta = FALSE; 
      }
      else {
        mostrar_etiqueta = TRUE;
    }
    break;

  case JK_m: // Rote el modo de control de camara
    switch ( modo_control ) {
      case CAM_STANDARD: modo_control = CAM_VUELO; break;
      default: modo_control = CAM_STANDARD; break;
    }
    break;

  case JK_i: // Imprime el estado de la camara :-)
    imprimir();
    break;

  case JK_N:    AUMENTAR(_near_plane);    imprimir();    break;
  case JK_n:    DISMINUIR(_near_plane);   imprimir();    break;
  case JK_F:    AUMENTAR(_far_plane);    imprimir();    break;
  case JK_f:    DISMINUIR(_far_plane);   imprimir();    break;

//---------------------------------------------------------------------------
  default:  return FALSE;
    }
    return TRUE;
}

BOOLEAN
CAMARA::procesar_mouse(EVENTO_GUI *e)
{
    static BOOLEAN mover_plano_viz = FALSE;
    static BOOLEAN girar_plano_viz = FALSE;
    static BOOLEAN avanzar = FALSE;
    MATRIZ_4x4 R, S;
    VECTOR u, v, w;
    double ax, ay;

    if ( e->mouse_delta_x > 5 ) e->mouse_delta_x = 5;
    if ( e->mouse_delta_x < -5 ) e->mouse_delta_x = -5;
    if ( e->mouse_delta_y > 5 ) e->mouse_delta_y = 5;
    if ( e->mouse_delta_y < -5 ) e->mouse_delta_y = -5;
    if ( e->tipo_de_evento == ETYPE_BUTTON_DOWN ) {
        mover_plano_viz = FALSE;
        girar_plano_viz = FALSE;
        avanzar = FALSE;
        if ( e->mouse_button_mask & 0x01 ) girar_plano_viz = TRUE;
        if ( e->mouse_button_mask & 0x02 ) mover_plano_viz = TRUE;
        if ( e->mouse_button_mask & 0x04 ||
             e->mouse_button_mask == 0x03 ) avanzar = TRUE;
      }
      else if ( e->tipo_de_evento == ETYPE_BUTTON_UP ) {
        mover_plano_viz = FALSE;
        girar_plano_viz = FALSE;
        avanzar = FALSE;
      }
      else {
        R.importar_quaternion(_orientacion);
        u.x = R.M[0][0];    u.y = R.M[1][0];    u.z = R.M[2][0];
        v.x = R.M[0][1];    v.y = R.M[1][1];    v.z = R.M[2][1];
        w.x = R.M[0][2];    w.y = R.M[1][2];    w.z = R.M[2][2];
        if ( mover_plano_viz ) {
            _posicion = _posicion - v * (0.1*((double)e->mouse_delta_x));
            _posicion = _posicion - w * (0.1*((double)e->mouse_delta_y));
        }
        if ( avanzar ) {
            //_posicion = _posicion - v * (0.1*((double)e->mouse_delta_x));
            _posicion = _posicion - u * (0.1*((double)e->mouse_delta_y));
        }
        if ( girar_plano_viz ) {
            ax = MINIMO(-(0.01*((double)e->mouse_delta_x)), 2);
            ay = MINIMO((0.01*((double)e->mouse_delta_y)), 2);

            S.rotacion_eje(ay, v.x, v.y, v.z);
            R = S * R;

            S.rotacion_eje(ax, 0, 0, 1);
            R = S * R;

            _orientacion = R.exportar_quaternion();
            _orientacion.normalizar();
            //imprimir();
        }
    }
    ;
    return TRUE;
}

void
CAMARA::procesar_resize(int xtam, int ytam)
{
    _ventana_xtam = xtam;
    _ventana_ytam = ytam;
}

//= SERVICIOS DE PERSISTENCIA ===============================================

BOOLEAN
CAMARA::leer(TOKENIZADOR *Sabiondo)
{
    char cad[1000];
    int tipo_token = TK_DESCONOCIDO, pos;
    VECTOR direccion;
    double magnitud, yaw, pitch, roll;
    MATRIZ_4x4 R;

    //- Ejecute el parser especifico de la COSA_RIGIDA -----------------
    pos = 1;
    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, "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, "orientacion") == 0 ) {
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_NUMERO, "un numero (magnitud de rotacion)");
                  magnitud = DEG2RAD(atof(cad));  // OJO: Y este signo que?
                  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();
                  _orientacion.importar_angulo_eje(magnitud, direccion);
                }
                else if ( strcmp(cad, "orientacion_euler") == 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_NUMERO, "un numero (dato 2 de un VECTOR)");
                  pitch = DEG2RAD(atof(cad));
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_VECTOR_FIN, "el final de un VECTOR");
                  cad[strlen(cad) - 1] = '\0';
                  roll = DEG2RAD(atof(cad));
                  R.rotacion_angulos_euler(yaw, pitch, roll);
                  _orientacion = R.exportar_quaternion();
                }
                else if ( strcmp(cad, "fov") == 0 ) {
                    tipo_token = Sabiondo->siguiente_token(cad);
                    ESPERO(TK_NUMERO, "un numero");
                    _fov = atof(cad);
                }
                else if ( strcmp(cad, "far_plane") == 0 ) {
                    tipo_token = Sabiondo->siguiente_token(cad);
                    ESPERO(TK_NUMERO, "un numero");
                    _far_plane = atof(cad);
                }
                else if ( strcmp(cad, "near_plane") == 0 ) {
                    tipo_token = Sabiondo->siguiente_token(cad);
                    ESPERO(TK_NUMERO, "un numero");
                    _near_plane = atof(cad);
                }
                else if ( strcmp(cad, "tipo_modelo") == 0 ) {
                    tipo_token = Sabiondo->siguiente_token(cad);
                    ESPERO(TK_NUMERO, "un numero");
                    tipo_modelo = (int)floor(atof(cad));
                }
                else if ( strcmp(cad, "mostrar_etiqueta") == 0 ) {
                    tipo_token = Sabiondo->siguiente_token(cad);
                    ESPERO(TK_IDENTIFICADOR, "TRUE o FALSE");
                    if ( strcmp(cad, "TRUE") == 0 ) mostrar_etiqueta = TRUE;
                    else mostrar_etiqueta = FALSE;
                }
                else if ( strcmp(cad, "proyeccion") == 0 ) {
                    tipo_token = Sabiondo->siguiente_token(cad);
                    ESPERO(TK_IDENTIFICADOR, "PERSPECTIVA o PARALELA");
                    if ( strcmp(cad, "PARALELA") == 0 )
                        _modo_proyeccion = CAM_PARALELA;
                    else _modo_proyeccion = CAM_PERSPECTIVA;
                }
                else if ( strcmp(cad, "transparencia_etiqueta") == 0 ) {
                    tipo_token = Sabiondo->siguiente_token(cad);
                    ESPERO(TK_NUMERO, "un numero entre 0 y 1");
                    transparencia_etiqueta = atof(cad);
                }
                else if ( strcmp(cad, "color_etiqueta") == 0 ) {
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_VECTOR_INICIO, "el inicio de un COLOR");
                  color_etiqueta.r = (float)atof(&cad[1]);
                  tipo_token = Sabiondo->siguiente_token(cad);
                  ESPERO(TK_NUMERO, "un numero (dato 2 de un COLOR)");
                  color_etiqueta.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_etiqueta.b = (float)atof(cad);
                }
                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, "<CAMARA> - ERROR: No hay memoria!\n");
                        fflush(stderr);
                        return FALSE;
                    }
                    strcpy(_nombre_padre, cad);
                }
              ;
              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.