Polygon.h

Go to the documentation of this file.

/* $Id: Polygon.h,v 1.3 2002/11/05 14:31:15 anonymous Exp $ */

#ifndef __POLYGON_H
#define __POLYGON_H

#include <esg/geometry/Geometry.h>

namespace esg {

class OGSCENE_EXPORT Polygon : public Geometry {
public:
        enum edgeProjection { XY, YZ, XZ, NONE_PROJ };
    
protected:
        Vector3*       _vertices;    
        Vector3*       _normals;     
        Vector2*       _uvCoords;    
        unsigned       _nVert;       
        Vector3        _normal;      
        bool           _normalFixed; 
        double         _fxyz;
        edgeProjection _edgeProjection;  
        double         _area;

        double  (*_proj)[6]; 
    
protected:
        virtual Mesh*   _mesh                 (int /* not used */) const;
        virtual void    _duplicate_attributes (const Geometry&);
        virtual Vector3 _get_facet_normal     (void)     const;
        virtual Vector3 _get_vertex           (unsigned) const;
        virtual Vector3 _get_vert_normal      (unsigned) const;
        virtual Vector2 _get_vert_uv_coord    (unsigned) const;
        virtual void    _rotateX   (float /* angle */);
        virtual void    _rotateY   (float /* angle */);
        virtual void    _rotateZ   (float /* angle */);
        virtual void    _rotate    (float /* angle */,const Vector3& /*axis*/);
        virtual void    _rotate    (const Matrix3&);
        virtual void    _translate (float /*x*/, float /*y*/, float /*z*/);
        virtual void    _transform (const Matrix4&);
        virtual void    _scale     (float);
    
        void     _set_edge_projection   (void);
        double (*_precompute_proj       (void)) [6];
        bool     _separation_by_plane   (const Geometry&) const;
        bool     _separation_by_edges   (Geometry&) const;
        bool     _point_inside_polygon  (const Vector3&, Vector3*, Vector2*);
        bool     _coplanar_tri_collision(Polygon&,
                                         const Vector3& v0,
                                         const Vector3& v1,
                                         const Vector3& v2,
                                         const Vector3& u0,
                                         const Vector3& u1,
                                         const Vector3& u2);
        
        int _triTriCollision (Polygon& /* triangle */);

    

public:
        Polygon();

        Polygon (const Vector3* va,
                 const Vector3* na,
                 const Vector2* uva,
                 unsigned       n);

        Polygon (const Vector3* va,
                 const Vector3* na,
                 const Vector2* uva,
                 unsigned       n,
                 const Vector3& norm,
                 bool           fixedn);

        virtual ~Polygon ();

        virtual void rayIntersection (PointEnv*      pPE,
                                      int            mask,
                                      const Vector3& origin,
                                      const Vector3& direction,
                                      float          maxD = MAXFLOAT);

        virtual bool mapToUV (const Vector3& v, Vector2& uv);

        virtual void randomSample (int mask, PointEnv& pe, double* pdf);

        virtual bool randomDirection (const Vector3& pov,
                                      Vector3&       dir,
                                      double*        pdf);

        virtual Interval extent (const Vector3& direction) const;

        virtual Vector3 centroid (void) const;

        virtual double radius (const Vector3& centroid) const;

        virtual Geometry* clone (const Matrix4* pTrMat) const;

        virtual bool separation (Geometry& geom, Vector3*  pDir);

        virtual double distance (const Geometry& geom, Vector3* pDir);

        virtual void dump (const char* intent, const char* tab);

        inline bool pointInsidePolygon (const Vector3& p,
                                        Vector3*       n,
                                        Vector2*       u) {
            return _point_inside_polygon(p,n,u);
        }

        virtual Vector3 getFacetNormal (void) const;

        virtual bool haveFixedNormal (void) const;

        virtual Vector3 getVertex (unsigned index) const;

        virtual Vector3 getVertNormal (unsigned index) const;

        virtual bool haveVertNormals (void) const;

        virtual Vector2 getVertUVCoord (unsigned) const;

        virtual bool haveVertUVCoords (void) const;

        virtual unsigned numVertices (void) const;

        virtual double getFXYZ (void) const;

        virtual edgeProjection getEdgeProjection (void) const;

        bool setVertices(const Vector3* va, unsigned n);

        bool setNormals(const Vector3* na);

        bool setUVCoords(const Vector2* uva);

        void setFacetNormal(const Vector3& norm, bool fixedn);

        virtual void __debug (void);
};

}; // namespace

#endif // __POLYGON_H

---