particulas.C

Ir a la documentación de este archivo.

//===========================================================================
//= particulas.h                                             Abril del 2000 =
//=-------------------------------------------------------------------------=
//= Modelo de un sistema de particulas que simula un efecto de lluvia.      =
//=-------------------------------------------------------------------------=
//= 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").                                         =
//=-------------------------------------------------------------------------=
//= Este programa esta basado en el modelo del ejemplo "rain" de Mesa, por  =
//= David Bucciarelli (tech.hmw@plus.it)                                    =
//=-------------------------------------------------------------------------=
//= 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 <stdlib.h>

#include "core/cosas/particulas.h"
#include "arreglo.cc"

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

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

//===========================================================================
/*
OJO: Esto NO es nada bueno... debe pensarse en alguna manera efectiva de
     reemplazar estas variables estaticas...
*/

VECTOR PARTICULA::LIMITE_min;
VECTOR PARTICULA::LIMITE_max;
double PARTICULA::LONGITUD_raya=0.1;

//===========================================================================
//= Clase SISTEMA_DE_PARTICULAS                                             =
//===========================================================================

SISTEMA_DE_PARTICULAS::SISTEMA_DE_PARTICULAS(int num_particulas,
    double largo_particulas, VECTOR min, VECTOR max) 
    : arr_particulas(100)
{
    PARTICULA *p;
    int i;

    PARTICULA::set_limites(min, max);
    PARTICULA::set_largo(largo_particulas);

    for( i = 0; i < num_particulas; i++ ) {
        p = new PARTICULA;
        arr_particulas.anx(p);
    }

    t = 0.0f;
}

SISTEMA_DE_PARTICULAS::~SISTEMA_DE_PARTICULAS()
{
    int i;

    for ( i = 0; i < arr_particulas.tam(); i++ ) {
        delete arr_particulas[i];
    }
    arr_particulas.elim();
    t = 0.0f;
}

#ifdef GL_ENABLED

void
SISTEMA_DE_PARTICULAS::pintar_gl(CAMARA *Camara)
{
    //-----------------------------------------------------------------------
    VECTOR p, min, max;
    p = Camara->posicion();
    min.x = p.x - 7;    min.y = p.y - 7;    min.z = -0.2;
    max.x = p.x + 7;    max.y = p.y + 7;    max.z = 8;
    PARTICULA::set_limites(min, max);

    //-----------------------------------------------------------------------
    int i;

    glDisable(GL_LIGHTING);
    glEnable(GL_DEPTH_TEST);
    glShadeModel(GL_SMOOTH);

    glBegin(GL_LINES);
        for( i = 0; i < arr_particulas.tam(); i++ ) {
            arr_particulas[i]->pintar_gl();
        }
    glEnd();
}

#endif

void
SISTEMA_DE_PARTICULAS::actualizar(double dt)
{
    int i;

    for( i = 0; i < arr_particulas.tam(); i++ ) {
        arr_particulas[i]->actualizar(dt);
    }
}

BOOLEAN
SISTEMA_DE_PARTICULAS::leer(TOKENIZADOR *Sabiondo)
{
    char cad[1000];
    int tipo_token = TK_DESCONOCIDO, pos;

    //- Ejecute el parser especifico de la COSA_RIGIDA -----------------
    pos = 2;
    while ( tipo_token != TK_CERRAR) {
        tipo_token = Sabiondo->siguiente_token(cad);
        switch ( pos ) {
            case 2:  ESPERO(TK_ABRIR, "\"{\"");  pos++; break;
            default:
              if ( tipo_token == TK_CERRAR ) break;
              ESPERO(TK_IDENTIFICADOR, "un identificador (3)");
/* OJO: Esto hace falta! */
              break;
        }
    }

    return TRUE;
}

//===========================================================================
//= Clase PARTICULA                                                         =
//===========================================================================

PARTICULA::PARTICULA()
{ 
    init();

    // Inicialmente tengo una altura al azar
    pos.z = (LIMITE_max.z-LIMITE_min.z)*RANDOM()*2 + LIMITE_min.z;
    oldpos.z = pos.z-LONGITUD_raya*vel.z;
}

void
PARTICULA::set_limites(VECTOR _min, VECTOR _max)
{
    LIMITE_min = _min;
    LIMITE_max = _max;
}

void
PARTICULA::set_largo(double l)
{
    LONGITUD_raya=l;
}

void
PARTICULA::init(void)
{
    acc.x = 0;    acc.y = 0;    acc.z = -0.98;
    vel.x = 0;    vel.y = 0;    vel.z = 0;

    oldpos.x = pos.x = LIMITE_min.x + (LIMITE_max.x-LIMITE_min.x)*RANDOM();
    oldpos.y = pos.y = LIMITE_min.y + (LIMITE_max.y-LIMITE_min.y)*RANDOM();
    oldpos.z = pos.z = LIMITE_max.z + 0.2*LIMITE_max.z*RANDOM();
}

#ifdef GL_ENABLED

void
PARTICULA::pintar_gl(void)
{
    glColor4f(0.7f,0.95f,1.0f,0.0f);
    glVertex3d(oldpos.x, oldpos.y, oldpos.z);

    glColor4f(0.3f,0.7f,1.0f,1.0f);
    glVertex3d(pos.x, pos.y, pos.z);
}

#endif

void
PARTICULA::actualizar(double dt)
{
    // Evaluo mi dinamica!
    vel = vel + acc*dt;
    pos = pos + vel*dt;

    if( pos.x < LIMITE_min.x )  pos.x = LIMITE_max.x - (LIMITE_min.x - pos.x);
    if( pos.y < LIMITE_min.y )  pos.y = LIMITE_max.y - (LIMITE_min.y - pos.y);
    if( pos.x > LIMITE_max.x )  pos.x = LIMITE_min.x + (pos.x - LIMITE_max.x);
    if( pos.y > LIMITE_max.y )  pos.y = LIMITE_min.y + (pos.y - LIMITE_max.y);

    oldpos = pos - vel*LONGITUD_raya;

    // Si me pase del piso, "reencarno" en otra gotica...
    if( pos.z < LIMITE_min.z ) init();
}

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