LrGeometryPoint.h 3.75 KB
Newer Older
1
/**
2
 * @brief GÉOMÉTRIE : Gestion d'un point
3
 * @file LrGeometryPoint.h
4 5
 * @date Vendredi 7 mars 2008
 * @note 
6 7 8 9 10
 * @author Josselin Francois
 * @author Michael Nauge
 * @author Axel Richard
 * @author Hervé Souchaud
 * @author Emeric Verschuur
11 12
 * 
 * Ce fichier contient la classe qui gère une géométrie ponctuelle.
13 14
 */

15 16 17
#ifndef LRGEOMETRYPOINT_H
#define LRGEOMETRYPOINT_H
#include "LrGeometry.h"
18 19

/**
20
 * @brief GÉOMÉTRIE : Gestion d'une géométrie ponctuelle
21
 * 
22
 * Cette classe gère une géométrie ponctuelle.
23 24 25 26 27
 */
class LrGeometryPoint : public LrGeometry
{
public:
    /**
28
     * @brief Constructeur.
29 30
     */
    LrGeometryPoint();
31
    
32 33
    /**
     * @brief Constructeur par copie.
34
     * @param src Référence d'un objet LrGeometryPoint.
35 36
     */
    LrGeometryPoint(const LrGeometryPoint& src);
37
    
38
    /**
39
     * @brief Destructeur.
40 41
     */
    virtual ~LrGeometryPoint();
42
    
43
    /**
44 45 46 47 48
     * @brief Opérateur d'affectation.
     * @param src Géométrie source.
     * @return Une référence sur l'objet affecté.
     */
    LrGeometryPoint& operator = (const LrGeometryPoint& src);
49
    
50 51
    /**
     * @brief Opérateur de test d'égalité.
52
     * @return vrai ou faux.
53
     */
54
    friend bool operator == (const LrGeometryPoint& rhs, const LrGeometryPoint& lhs);
55
    
56 57
    /**
     * @brief Opérateur de test d'inégalité.
58
     * @return vrai ou faux.
59
     */
60
    friend bool operator != (const LrGeometryPoint& rhs, const LrGeometryPoint& lhs);
61
    
62 63 64 65 66 67
    /**
     * @brief Donne le nombre de fragments de la géométrie.
     * @return Un entier.
     */
    virtual int getNbFragments() const;
    
68 69
    /**
     * @brief Donne d'intersection entre un rayon et la géométrie.
70 71
     * @param ray Référence d'un objet LrRay.
     * @param hit Adresse de l'objet LrHit dans lequel sera stocké le résultat.
72
     * @param fragment Fragment de la géométrie.
73 74
     * @param minBound Distance minimum par rapport à l'origine (défaut : 0).
     * @param maxBound Distance maximum par rapport à l'origine (défaut : INFINITY).
75
     * @return vrai si il y a une intersection, sinon faux.
76 77 78 79 80 81 82
     *
     * Cette méthode calcul l'intersection entre le rayon @a ray et la géométrie
     * et stocke le résultat dans la sructure LrHit pointée par @a hit si ce
     * dernier n'est pas égal à NULL. On peut également spécifier la portion du
     * rayon, à l'aide des paramètres @a minBound @a maxBound , à prendre en
     * compte pour ce calcul.
     */
Emeric Verschuur's avatar
Emeric Verschuur committed
83
    virtual bool getIntersection(const LrRay &ray, LrHit *hit, int fragment,
84
                                 Real minBound=0, Real maxBound=INFINITY) const;
85
    
86 87 88
    /**
     * @brief Calcul des points min et max de la boîte englobante.
     * @param min LrPoint minimum de la boîte.
89
     * @param max LrPoint maximum de la boîte.
90
     * @param fragment Fragment de la géométrie.
91 92 93 94 95 96
     *
     * Calcule le point "en bas, devant, à gauche" et le point "en haut,
     * derrière, à droite" de la géométrie.
     */
    virtual void getMinMax(LrPoint &min, LrPoint &max, int fragment) const;
    
97 98 99 100 101 102 103
protected:
    /**
     * @brief Conversion de coordonnées absolues en paramétriques.
     * @param point Point à convertir.
     * @param u Réel u (paramètre out).
     * @param v Réel v (paramètre out).
     */
104
    virtual void xyz2uv(const LrPoint &point, Real &u, Real &v) const;
105
    
106 107 108 109 110 111 112
    /**
     * @brief Conversion de coordonnées paramétriques en absolues.
     * @param u Réel u.
     * @param v Réel v.
     * @param point Point résultant (paramètre out).
     * @param normal Normale à ce point (paramètre out).
     * @param tangent Tangente à ce point (paramètre out).
113
     */
114
    virtual void uv2xyz(Real u, Real v, LrPoint *point,
115
                        LrVector *normal, LrVector *tangent) const;
116
    
117 118 119 120
private:
};

#endif