cubo.h

Ir a la documentación de este archivo.

//===========================================================================
//= cubo.h                                                    Marzo de 1999 =
//=-------------------------------------------------------------------------=
//= Definiciones de la clase CUBO.                                          =
//= NOTA: No incluya este encabezado en los modulos.  Incluya a             =
//=       geometria.h.                                                      =
//=-------------------------------------------------------------------------=
//= 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. =
//===========================================================================

#ifndef __CUBO__
#define __CUBO__

#include "jed_defs.h"

#ifndef __GEOMETRIA__
    #error "No incluya a cubo.h, incluya a geometria.h!"
#endif

#ifdef VEL_ROSITA
    #include "toolkits/geom/geometria.h"
#endif

class CUBO : public PRIMITIVA_GEOMETRICA 
{
  private:
    double _lado;
    IMAGEN *imagen;
  public:
    CUBO(double l);
    virtual ~CUBO();
    double lado(void);
    void set_lado(double l);
    void minmax(VECTOR *min, VECTOR *max);
#ifdef GL_ENABLED
    void
    pintar_gl(CALIDAD_VISUAL *Calidad, MATERIAL* Material, CAMARA *Camara);
#endif
    void pintar_povray(FILE *fd);
    void pintar_aqz(FILE *fd);
    void anexar_textura(IMAGEN *img);
    int clasificar_punto(VECTOR p);
    virtual GEOMETRIA *crear_copia(void);
    double interseccion(RAYO *Rayo, VECTOR &punto, VECTOR &normal);
};

//===========================================================================
//= Metodos inline de la clase CUBO                                         =
//===========================================================================

inline double
CUBO::interseccion(RAYO *Rayo, VECTOR &punto, VECTOR &normal)
{
    double t, min_t = INFINITO;
    double l2 = _lado/2;  // OJO: Esto deberia venir precalculado
    VECTOR p;

    // Plano superior: Z = _lado/2
    if ( fabs(Rayo->direccion.z) > EPSILON ) {
        // El rayo no es paralelo al plano Z=_lado/2
        t = (l2-Rayo->origen.z)/Rayo->direccion.z;
        if ( t > -EPSILON ) {
            p = Rayo->origen + Rayo->direccion * t;
            if ( p.x >= -l2 && p.x <= l2 && 
                 p.y >= -l2 && p.y <= l2 ) {
                normal.x = normal.y = 0;
                normal.z = 1;
                punto = p;
                min_t = t;
            }
        }
    }

    // Plano inferior: Z = -_lado/2
    if ( fabs(Rayo->direccion.z) > EPSILON ) {
        // El rayo no es paralelo al plano Z=-_lado/2
        t = (-l2-Rayo->origen.z)/Rayo->direccion.z;
        if ( t > -EPSILON && t < min_t ) {
            p = Rayo->origen + Rayo->direccion * t;
            if ( p.x >= -l2 && p.x <= l2 && 
                 p.y >= -l2 && p.y <= l2 ) {
                normal.x = normal.y = 0;
                normal.z = -1;
                punto = p;
                min_t = t;
            }
        }
    }

    // Plano frontal: Y = _lado/2
    if ( fabs(Rayo->direccion.y) > EPSILON ) {
        // El rayo no es paralelo al plano Y=_lado/2
        t = (l2-Rayo->origen.y)/Rayo->direccion.y;
        if ( t > -EPSILON && t < min_t ) {
            p = Rayo->origen + Rayo->direccion * t;
            if ( p.x >= -l2 && p.x <= l2 && 
                 p.z >= -l2 && p.z <= l2 ) {
                normal.x = normal.z = 0;
                normal.y = 1;
                punto = p;
                min_t = t;
            }
        }
    }

    // Plano posterior: Y = -_lado/2
    if ( fabs(Rayo->direccion.y) > EPSILON ) {
        // El rayo no es paralelo al plano Y=-_lado/2
        t = (-l2-Rayo->origen.y)/Rayo->direccion.y;
        if ( t > -EPSILON && t < min_t ) {
            p = Rayo->origen + Rayo->direccion * t;
            if ( p.x >= -l2 && p.x <= l2 && 
                 p.z >= -l2 && p.z <= l2 ) {
                normal.x = normal.z = 0;
                normal.y = -1;
                punto = p;
                min_t = t;
            }
        }
    }

    // Plano X = _lado/2
    if ( fabs(Rayo->direccion.x) > EPSILON ) {
        // El rayo no es paralelo al plano X=_lado/2
        t = (l2-Rayo->origen.x)/Rayo->direccion.x;
        if ( t > -EPSILON && t < min_t ) {
            p = Rayo->origen + Rayo->direccion * t;
            if ( p.y >= -l2 && p.y <= l2 && 
                 p.z >= -l2 && p.z <= l2 ) {
                normal.y = normal.z = 0;
                normal.x = 1;
                punto = p;
                min_t = t;
            }
        }
    }

    // Plano X = -_lado/2
    if ( fabs(Rayo->direccion.x) > EPSILON ) {
        // El rayo no es paralelo al plano X=-_lado/2
        t = (-l2-Rayo->origen.x)/Rayo->direccion.x;
        if ( t > -EPSILON && t < min_t ) {
            p = Rayo->origen + Rayo->direccion * t;
            if ( p.y >= -l2 && p.y <= l2 && 
                 p.z >= -l2 && p.z <= l2 ) {
                normal.y = normal.z = 0;
                normal.x = -1;
                punto = p;
                min_t = t;
            }
        }
    }

    if ( min_t < INFINITO ) return min_t;
    return 0;
}

#endif

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