vista.C

Ir a la documentación de este archivo.

//===========================================================================
//= vista.cc                                                  Julio de 1998 =
//=-------------------------------------------------------------------------=
//= Definicion de clase VISTA.  Esta clase juega el rol de "Abstraction" en =
//= un patron "BRIDGE" (ver [GAMMA95] - "Design patterns, elements of       =
//= reusable object-oriented software"), en donde el "Implementor" es la    =
//= clase VISOR.                                                            =
//=-------------------------------------------------------------------------=
//= APLICACIONES DE LA CLASE:                                               =
//= Para una aplicacion basada en OpenGL, y dado un contexto OpenGL, esta   =
//= clase permite que en dicho contexto evolucione un VISOR, el cual puede  =
//= ser cambiado por otro dinamicamente en cualquier momento.  Esto se      =
//= traduce en poder usar un mismo contexto OpenGL para mostrar distintas   =
//= vistas de la informacion de una aplicacion.                             =
//= Por otro lado, al proveer un identificador, la VISTA facilita la        =
//= creacion de aplicaciones que tienen varios contextos OpenGL.            =
//=-------------------------------------------------------------------------=
//= 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 "framework/visual/vista.h"
#include <stdio.h>
#include <stdlib.h>

//===========================================================================
//= Macros utilitarias                                                      =
//===========================================================================

#define COLOCAR_IMAGEN_GL()                 \
    if ( !modo_offline ) {                  \
        glViewport(_x, _y, _x_tam, _y_tam); \
        glMatrixMode(GL_MODELVIEW);         \
        glPushMatrix();                     \
        glLoadIdentity();                   \
        glMatrixMode(GL_PROJECTION);        \
        glPushMatrix();                     \
        glLoadIdentity();                   \
        glMatrixMode(GL_MODELVIEW);         \
        glClear(GL_DEPTH_BUFFER_BIT);       \
        Imagen->pintar_gl();                \
        glMatrixMode(GL_PROJECTION);        \
        glPopMatrix();                      \
        glLoadIdentity();                   \
        glMatrixMode(GL_MODELVIEW);         \
        glPopMatrix();                      \
        glLoadIdentity();                   \
    }

#define INICIALIZAR_IMAGEN(tipo)                                        \
{   Imagen = new tipo();                                                \
    if ( !Imagen || !Imagen->init(_x_tam, _y_tam) ) {                   \
        fprintf(stderr,"<VISTA> - Error: "                              \
            "no hay memoria para una IMAGEN de %d x %d pixels!\n",      \
            _x_tam, _y_tam);                                            \
        fflush(stderr);                                                 \
        return;                                                         \
    }}

#ifdef GL_ENABLED
#define GENERAR_VISTA_VACIA()                   \
    _metodo_de_visualizacion = MDV_ZBUFFER;     \
    delete Imagen; Imagen = NULL;               \
    if ( !modo_offline ) {                      \
        pintar_nucleo();                        \
        return;                                 \
    }                                           \
    INICIALIZAR_IMAGEN(IMAGEN_RGBA);            \
    ((IMAGEN_RGBA *)Imagen)->activar_como_contexto_gl();         \
    pintar_nucleo();                            \
    return;
#endif

#ifndef GL_ENABLED
#define GENERAR_VISTA_VACIA()                   \
    _metodo_de_visualizacion = MDV_ZBUFFER;     \
    delete Imagen; Imagen = NULL;               \
    if ( !modo_offline ) {                      \
        pintar_nucleo();                        \
        return;                                 \
    }                                           \
    INICIALIZAR_IMAGEN(IMAGEN_RGBA);            \
    pintar_nucleo();                            \
    return;
#endif

//===========================================================================
//= CLASE VISTA                                                             =
//===========================================================================

VISTA::VISTA(VISOR *v, int el_id)
{
    Imagen = NULL;
    modo_offline = FALSE;
    //_metodo_de_visualizacion = MDV_ZBUFFER;
    //_metodo_de_visualizacion = MDV_RAYTRACING_CRIOLLO;
    //_metodo_de_visualizacion = MDV_RAYTRACER_POVRAY;

    _metodo_de_visualizacion = v->metodo_de_visualizacion();

    _x = _y = 0;    _x_tam = 320;    _y_tam = 240;
    mi_visor = v;
    _id = el_id;
}

VISTA::~VISTA()
{
    if ( mi_visor ) delete mi_visor;
}

int VISTA::id(void) {    return _id; }
int VISTA::x(void) {    return _x; }
int VISTA::y(void) {    return _y; }
int VISTA::xtam(void) {    return _x_tam; }
int VISTA::ytam(void) {    return _y_tam; }
void VISTA::set_x(int x) { _x = x; }
void VISTA::set_y(int y) { _y = y; }
void VISTA::set_xtam(int x_tam) { _x_tam = x_tam; }
void VISTA::set_ytam(int y_tam) { _y_tam = y_tam; }
void VISTA::set_id(int i) { _id = i; }
VISOR * VISTA::visor(void) {  return mi_visor; }

void VISTA::set_metodo_de_visualizacion(int metodo)
    { _metodo_de_visualizacion = metodo; }

int
VISTA::metodo_de_visualizacion(void)
{
    return _metodo_de_visualizacion;
}

void
VISTA::pintar_nucleo(void)
{
    switch ( _metodo_de_visualizacion ) {
      //----------------------------------------------------------------------
      case MDV_RAYTRACING_CRIOLLO:
        if ( !modo_offline && !Imagen ) INICIALIZAR_IMAGEN(IMAGEN_RGB);
        if ( mi_visor ) {
            if ( !mi_visor->pintar_raytracing_criollo((IMAGEN_RGB*)Imagen) ) {
                GENERAR_VISTA_VACIA();
            }
        }
      #ifdef GL_ENABLED
        COLOCAR_IMAGEN_GL();
      #endif
        break;

      //----------------------------------------------------------------------
      case MDV_RAYTRACER_POVRAY:
        if ( !modo_offline && !Imagen ) INICIALIZAR_IMAGEN(IMAGEN_RGB);
        if ( mi_visor ) {
            if ( modo_offline ) { 
                INICIALIZAR_IMAGEN(IMAGEN_RGB);
                if ( !mi_visor->pintar_povray((IMAGEN_RGB *)Imagen,
                                              "output/test.pov", FALSE) ) {
                    GENERAR_VISTA_VACIA();
                }
                delete Imagen;
                Imagen = NULL;
              }
              else {
                if ( !mi_visor->pintar_povray((IMAGEN_RGB *)Imagen,
                                              "output/test.pov", TRUE) ) {
                    GENERAR_VISTA_VACIA();
                }
            }
        }
      #ifdef GL_ENABLED
        COLOCAR_IMAGEN_GL();
      #endif
        break;

      //----------------------------------------------------------------------
      case MDV_ZBUFFER: default:
      #ifdef GL_ENABLED
        glViewport(_x, _y, _x_tam, _y_tam);
        if ( mi_visor ) mi_visor->pintar_gl();
      #endif

        break;
    }
}

void
VISTA::pintar_online(void)
{
#ifdef GL_ENABLED
    if ( modo_offline && Imagen &&
         _metodo_de_visualizacion == MDV_RAYTRACING_CRIOLLO ) {
        ((IMAGEN_RGBA *)Imagen)->desactivar_como_contexto_gl();
    }

    modo_offline = FALSE;
    pintar_nucleo();
#endif
}

void
VISTA::pintar_offline(char *archivo)
{
    //- 1. Si no tengo una IMAGEN de trabajo, la creo ----------------------
    // Notese que en modo offline con raytracers externos no se usa la imagen!

    if ( !Imagen &&
         _metodo_de_visualizacion != MDV_RAYTRACER_POVRAY ) {
        if ( _metodo_de_visualizacion == MDV_RAYTRACING_CRIOLLO ) {
            INICIALIZAR_IMAGEN(IMAGEN_RGB);
          }
          else {
            INICIALIZAR_IMAGEN(IMAGEN_RGBA);
        }
    }

    //- 2. Dependiendo del modo, activo la IMAGEN como contexto OpenGL ------
    //-    pero solo cada que se crea una imagen nueva ----------------------
    if ( !modo_offline && _metodo_de_visualizacion == MDV_ZBUFFER ){
#ifdef GL_ENABLED
        ((IMAGEN_RGBA *)Imagen)->activar_como_contexto_gl();
#endif
    }
    modo_offline = TRUE;

    //- 3. Aqui se llama el algoritmo de visualizacion! ---------------------
    pintar_nucleo();

    //- 4. Exporto la imagen al archivo solicitado --------------------------
    if ( _metodo_de_visualizacion != MDV_RAYTRACER_POVRAY ) {
        FILE *fd = fopen(archivo, "wb");
        if ( !fd ) {
            fprintf(stderr, 
            "<VISTA> ERROR: No se puede escribir una imagen en %s.\n",archivo);
            exit(-2);
        }
        if ( _metodo_de_visualizacion == MDV_RAYTRACING_CRIOLLO ) {
            ((IMAGEN_RGB *)Imagen)->exportar_ppm(fd);
          }
          else {
            ((IMAGEN_RGBA *)Imagen)->exportar_ppm(fd);
        }
        fclose(fd);
    }
    if ( _metodo_de_visualizacion == MDV_RAYTRACER_POVRAY ) {
        char comando[2048];
        sprintf(comando, "mv ./output/test.ppm %s", archivo);
//        printf("===========================================================================\n");
        system(comando);
//        printf("\n===========================================================================\n");
    }
}

void
VISTA::procesar_resize(int x, int y, int x_tam, int y_tam)
{
    if ( modo_offline && Imagen &&
        _metodo_de_visualizacion != MDV_RAYTRACER_POVRAY ) {
#ifdef GL_ENABLED
        ((IMAGEN_RGBA *)Imagen)->desactivar_como_contexto_gl();
#endif
        delete Imagen;
        Imagen = NULL;
    }

    if ( _metodo_de_visualizacion == MDV_RAYTRACING_CRIOLLO && Imagen ) {
        delete Imagen;
        Imagen = NULL;
    }
    if ( _metodo_de_visualizacion == MDV_RAYTRACER_POVRAY && Imagen 
         && !modo_offline ) {
        delete Imagen;
        Imagen = NULL;
    }

    _x = x;
    _y = y;
    _x_tam = x_tam;
    _y_tam = y_tam;
    if ( mi_visor ) mi_visor->procesar_resize(_x, _y, _x_tam, _y_tam);
}

int
VISTA::procesar_teclado(EVENTO_GUI *e)
{
    if ( mi_visor ) return mi_visor->procesar_teclado(e);
    else return 0;
}

int
VISTA::procesar_mouse(EVENTO_GUI *e)
{
    if ( mi_visor ) return mi_visor->procesar_mouse(e);
    else return 0;
}

int
VISTA::procesar_comando(int idc)
{
    if ( mi_visor ) return mi_visor->procesar_comando(idc);
    else return 0;
}

char *
VISTA::reportar_menu(void)
{
    if ( mi_visor ) return mi_visor->reportar_menu();
    return NULL;
}

char *
VISTA::reportar_botonera(void)
{
    if ( mi_visor ) return mi_visor->reportar_botonera();
    return NULL;
}

void
VISTA::grabar(FILE *fd)
{
    if ( mi_visor ) mi_visor->grabar(fd);
}

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