control_3d_vector.C

Ir a la documentación de este archivo.

//===========================================================================
//= control_3d_vector.C                                    Abril 17 de 2003 =
//=-------------------------------------------------------------------------=
//= <descripcion del modulo>                                                =
//=-------------------------------------------------------------------------=
//= 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. =
//= Copyright (c), 1997-2003.                                               =
//===========================================================================

#include "jed_defs.h"
#include "framework/visual/control_3d.h"

//===========================================================================
//= Clases GIZMO. No deberian estar en este modulo!                         =
//===========================================================================

GIZMO_3D_IMPLEMENTADOR::GIZMO_3D_IMPLEMENTADOR(CONTROL_3D_VECTOR *in_Padre)
{
    _Padre = in_Padre;
}

GIZMO_3D_IMPLEMENTADOR::~GIZMO_3D_IMPLEMENTADOR()
{
    ;
}

//===========================================================================

GIZMO_3D_TRANSLACION_3DSMAX::GIZMO_3D_TRANSLACION_3DSMAX(
    CONTROL_3D_VECTOR *in_Padre) : GIZMO_3D_IMPLEMENTADOR(in_Padre)
{
    _zona_seleccionada_temporal = 0;
}

GIZMO_3D_TRANSLACION_3DSMAX::~GIZMO_3D_TRANSLACION_3DSMAX()
{
    ;
}

#ifdef GL_ENABLED
void
GIZMO_3D_TRANSLACION_3DSMAX::pintar_gl(CALIDAD_VISUAL *Calidad, 
                       MATERIAL* Material, CAMARA *Camara)
{
    COLOR r(1, 0, 0);
    COLOR g(0, 1, 0);
    COLOR b(0, 0, 1);
    COLOR a(1, 1, 0);

    //- Zona 1: Vector I ----------------------------------------------------
    glPushMatrix();
    glTranslated(0.5, 0, 0);
    if ( _zona_seleccionada_temporal == 1 ) {
        Material->set_difusa(a);
      }
      else {
        Material->set_difusa(r);
    }
    _Padre->_Eje->pintar_gl(Calidad, Material, Camara);
    glPopMatrix();

    //- Zona 2: Vector J ----------------------------------------------------
    glPushMatrix();
    glTranslated(0, 0.5, 0);
    glRotated(90, 0, 0, 1);
    if ( _zona_seleccionada_temporal == 2 ) {
        Material->set_difusa(a);
      }
      else {
        Material->set_difusa(g);
    }
    _Padre->_Eje->pintar_gl(Calidad, Material, Camara);
    glPopMatrix();

    //- Zona 3: Vector K ----------------------------------------------------
    glPushMatrix();
    glTranslated(0, 0, 0.5);
    glRotated(90, 0, -1, 0);
    if ( _zona_seleccionada_temporal == 3 ) {
        Material->set_difusa(a);
      }
      else {
        Material->set_difusa(b);
    }
    _Padre->_Eje->pintar_gl(Calidad, Material, Camara);
    glPopMatrix();

    //- Zona 4: Cuadrante de control para el plano XY -----------------------

    //- Zona 5: Cuadrante de control para el plano XZ -----------------------

    //- Zona 6: Cuadrante de control para el plano YZ -----------------------

    //- Zona 7: Cubo central de acceso a los tres ejes ----------------------

}
#endif // GL_ENABLED

BOOLEAN
GIZMO_3D_TRANSLACION_3DSMAX::procesar_mouse(EVENTO_GUI *e)
{
    RAYO r, r_prima;
    VECTOR p, n;
//    int antigua_zona = _zona_seleccionada_temporal;
    MATRIZ_4x4 R, R_i;

    if ( e->tipo_de_evento == ETYPE_BUTTON_DOWN &&
         (e->mouse_button_mask & 0x01) ) {
        _Padre->_boton1_mouse_abajo = TRUE;
        return TRUE;
      }
      else if ( e->tipo_de_evento == ETYPE_BUTTON_UP ) {
        _Padre->_boton1_mouse_abajo = FALSE;
        return TRUE;
      }
      else {
          if ( _Padre->_boton1_mouse_abajo &&
               (e->mouse_button_mask & 0x01) ) {
              // Estamos en modo de actualizacion de informacion
          switch ( _zona_seleccionada_temporal ) {
            case 1:
                  _Padre->_valor.x += ((double)e->mouse_delta_x)/60;
                  _Padre->set_valor(_Padre->_valor);
          break;
            case 2:
                  _Padre->_valor.y += ((double)e->mouse_delta_x)/60;
                  _Padre->set_valor(_Padre->_valor);
          break;
            case 3:
                  _Padre->_valor.z -= ((double)e->mouse_delta_y)/60;
                  _Padre->set_valor(_Padre->_valor);
          break;
            default: break;
          }
              return TRUE;
          }
          else {
              // Estamos en modo de seleccion
              if ( !_Padre->_Ultima_camara ) return FALSE;
              _Padre->_Ultima_camara->preprocesar_vista();
              r = _Padre->_Ultima_camara->generar_rayo(e->mouse_x, e->mouse_y);
          _zona_seleccionada_temporal = 0;

              // Intersectar con la zona 1
          r_prima.origen = r.origen - _Padre->_valor;
          r_prima.origen.x -= 0.5;
          r_prima.direccion = r.direccion;
              if ( _Padre->_Eje_gravedad->interseccion(&r_prima, p, n) ) {
          _zona_seleccionada_temporal = 1;
              }

              // Intersectar con la zona 2
          R.rotacion_angulos_euler(DEG2RAD(90), 0, 0);
          R_i = R.inversa();
          r_prima.origen = r.origen - _Padre->_valor;
          r_prima.origen.y -= 0.5;
              r_prima.origen = R_i * r_prima.origen;
          r_prima.direccion = R_i * r.direccion;
              if ( _Padre->_Eje_gravedad->interseccion(&r_prima, p, n) ) {
          _zona_seleccionada_temporal = 2;
              }

              // Intersectar con la zona 2
          R.rotacion_angulos_euler(0, -DEG2RAD(90), 0);
          R_i = R.inversa();
          r_prima.origen = r.origen - _Padre->_valor;
          r_prima.origen.z -= 0.5;
              r_prima.origen = R_i * r_prima.origen;
          r_prima.direccion = R_i * r.direccion;
              if ( _Padre->_Eje_gravedad->interseccion(&r_prima, p, n) ) {
          _zona_seleccionada_temporal = 3;
              }
          }
      }
    ;

// OJO: Esto deberia funcionar... pero no funciona! porque sera?
//      Por ahora toca hacer la super-INEFICIENTE salida de retornar siempre
//      TRUE!
//    printf("[%d,%d] ", _zona_seleccionada_temporal, antigua_zona);
//    fflush(stdout);
//    if ( _zona_seleccionada_temporal == antigua_zona ) return FALSE;

    return TRUE;
}

//===========================================================================
//= Clase CONTROL_3D_VECTOR                                                 =
//===========================================================================

CONTROL_3D_VECTOR::CONTROL_3D_VECTOR(JED_INTERFACE **p) : CONTROL_3D(p)
{
    Entidad_controlada = NULL;
    _nombre_subvariable = NULL;
    _boton1_mouse_abajo = FALSE;

    _Eje = new FLECHA(1, 0.3, 0.03, 0.075);
    _Eje_gravedad = new FLECHA(1, 0.3, 0.03, 0.075);
//    _Eje_gravedad = new FLECHA(1, 0.3, 0.08, 0.15);
    _Ultima_camara = NULL;
    _Implementador = new GIZMO_3D_TRANSLACION_3DSMAX(this);
}

CONTROL_3D_VECTOR::~CONTROL_3D_VECTOR()
{
    ;
}

void
CONTROL_3D_VECTOR::set_valor(VECTOR val)
{
    _valor = val;
    if ( Entidad_controlada ) {
        Entidad_controlada->actualizar_variable(_nombre_subvariable,
            T_VECTOR, (void *)(&_valor));
        Entidad_controlada->propagar_cambios();
        (*_Padre)->solicitar_repintado();
    }
}

void
CONTROL_3D_VECTOR::actualizar(ENTIDAD *Entidad)
{
    //-----------------------------------------------------------------------
    VECTOR *Nuevo_valor;
    int tipo = T_FLOAT;

    if ( !Entidad || !Entidad->consultar_variable(
          (const char *)_nombre_subvariable,
          tipo, (void**)(&Nuevo_valor)) ) return;

    _valor = *Nuevo_valor;
}

#ifdef GL_ENABLED
void
CONTROL_3D_VECTOR::pintar_gl(CALIDAD_VISUAL * /*Calidad*/, 
                             MATERIAL * /*Material*/, CAMARA *Camara)
{
    _Ultima_camara = Camara;

    //-----------------------------------------------------------------------
    CALIDAD_VISUAL cv_propia;
    MATERIAL m_propio;

    //-----------------------------------------------------------------------
    // OJO! Esto hace que estas funciones solo puedan ser llamadas una vez
    //      terminada de pintar la escena principal!
    glClear(GL_DEPTH_BUFFER_BIT);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);
    glPushMatrix();
    glLoadIdentity();

    // OJO: ESTO ESTA MAL: Solo es cierto si se esta controlando una posicion,
    //      de lo contrario la clase requiere un VECTOR adicional para poder
    //      localizar su gizmo... (y el valor de la translacion ya se puede
    //      pedir a `Entidad_controlada`.
    glTranslated(_valor.x, _valor.y, _valor.z);

    //-----------------------------------------------------------------------
    _Implementador->pintar_gl(&cv_propia, &m_propio, Camara);

    //-----------------------------------------------------------------------
    glPopMatrix();
}
#endif // GL_ENABLED

BOOLEAN
CONTROL_3D_VECTOR::procesar_mouse(EVENTO_GUI *e)
{
    return _Implementador->procesar_mouse(e);
}

void
CONTROL_3D_VECTOR::crear(REPOSITORIO_DE_ENTIDADES *Repositorio, char *nombre)
{
    ENTIDAD *e = Repositorio->buscar_entidad("_default", nombre);
    if ( e ) {
        Entidad_controlada = e;
        e->registrar_controlador(this);
    }
    _nombre_subvariable = new char[2];
    strcpy(_nombre_subvariable, "posicion");
}

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