paralele.h

Ir a la documentación de este archivo.

//===========================================================================
//= paralele.h                                                Marzo de 1999 =
//=-------------------------------------------------------------------------=
//= Definiciones de la clase PARALELEPIPEDO                                 =
//= 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 __PARALELEPIPEDO__
#define __PARALELEPIPEDO__

#include "jed_defs.h"

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

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

class PARALELEPIPEDO : public PRIMITIVA_GEOMETRICA 
{
  private:
    VECTOR _lados;
    IMAGEN *imagen;
  public:
    PARALELEPIPEDO(VECTOR l);
    PARALELEPIPEDO(double lx, double ly, double lz);
    virtual ~PARALELEPIPEDO();
    VECTOR lados(void);
    void set_lados(VECTOR 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 pintar_vrml(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
PARALELEPIPEDO::interseccion(RAYO *Rayo, VECTOR &punto, VECTOR &normal)
{
    double t, min_t = INFINITO;
    double l2x = _lados.x/2; 
    double l2y = _lados.y/2; 
    double l2z = _lados.z/2; 
    VECTOR p;

    // Plano superior: Z = _lado/2
    if ( fabs(Rayo->direccion.z) > EPSILON ) {
        // El rayo no es paralelo al plano Z=_lado/2
        t = (l2z-Rayo->origen.z)/Rayo->direccion.z;
        if ( t > -EPSILON ) {
            p = Rayo->origen + Rayo->direccion * t;
            if ( p.x >= -l2x && p.x <= l2x && 
                 p.y >= -l2y && p.y <= l2y ) {
                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 = (-l2z-Rayo->origen.z)/Rayo->direccion.z;
        if ( t > -EPSILON && t < min_t ) {
            p = Rayo->origen + Rayo->direccion * t;
            if ( p.x >= -l2x && p.x <= l2x && 
                 p.y >= -l2y && p.y <= l2y ) {
                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 = (l2y-Rayo->origen.y)/Rayo->direccion.y;
        if ( t > -EPSILON && t < min_t ) {
            p = Rayo->origen + Rayo->direccion * t;
            if ( p.x >= -l2x && p.x <= l2x && 
                 p.z >= -l2z && p.z <= l2z ) {
                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 = (-l2y-Rayo->origen.y)/Rayo->direccion.y;
        if ( t > -EPSILON && t < min_t ) {
            p = Rayo->origen + Rayo->direccion * t;
            if ( p.x >= -l2x && p.x <= l2x && 
                 p.z >= -l2z && p.z <= l2z ) {
                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 = (l2x-Rayo->origen.x)/Rayo->direccion.x;
        if ( t > -EPSILON && t < min_t ) {
            p = Rayo->origen + Rayo->direccion * t;
            if ( p.y >= -l2y && p.y <= l2y && 
                 p.z >= -l2z && p.z <= l2z ) {
                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 = (-l2x-Rayo->origen.x)/Rayo->direccion.x;
        if ( t > -EPSILON && t < min_t ) {
            p = Rayo->origen + Rayo->direccion * t;
            if ( p.y >= -l2y && p.y <= l2y && 
                 p.z >= -l2z && p.z <= l2z ) {
                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.