3DFace.h

Go to the documentation of this file.

//! @file 3DFace.h
//!
//! @brief C3DFace class definition for a 3D face, which is a list of indexes that refers to a 3D point list. 
//!
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_3DFACE_H__CA6BC29D_FAC2_11D1_A0DE_000000000000__INCLUDED_)
#define AFX_3DFACE_H__CA6BC29D_FAC2_11D1_A0DE_000000000000__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "Face.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
class C3DFacePropertyMethods;
//! @class C3DFacePropertyData
//! @brief C3DFacePropertyData is the main data chunk of C3DFaceList and it contains the face flags and its material id.
class C3DFacePropertyData : public CFacePropertyData
{
    friend C3DFacePropertyMethods;
    friend C3DFaceList;
    friend C3DFace;
 
    protected:
    MaterialID materialid;
 
    C3DFacePropertyData();
};
 
inline C3DFacePropertyData::C3DFacePropertyData()
{
    materialid = DEFAULT_MATERIAL_ID;
}
 
//! @class C3DFace
//! @brief A 3D face is a list of indexes of C3DPointList object point list.
//! @details A 3D face is usually built using a C3DFaceList::GetFace
class CTriangulateFaceHelper;
class DLL_3DFUNCTION C3DFace : public CFace
{
    friend class C3DFaceList;
 
    public:
    C3DFace();
 
    public:
    
    // Usefuls functions
    static CTriangulateFaceHelper *InitTriangulation(const CGeomInfo *info);
    static void ReleaseTriangulation(CTriangulateFaceHelper *helper);
 
 
    int Triangulate(CTriangulateFaceHelper *helper, int srcfacenbr, int dstfacenbr); //!< Triangulate the face. When called repeatly on multiple CFace of a C3DFaceList, this method is faster than the second one
 
    //!  Triangulate a face
    //! @param info
    //!     contains the face list as well as related channels which need to be triangulate
    //!     contains the preallocated destination face list and destination channels
    //!     source and destination list might contains only faces
    //! @param srcfacenbr
    //!     index of the face to triangulate
    //! @param dstfacenbr
    //!     index to which the new triangulated faces are copied
    //!     If dstfacenbr == -1 => we assume to triangulate only one face, and initialize the destination face list buffer
    //! @return The  number of new faces
    int Triangulate(const CGeomInfo *, int srcfacenbr, int dstfacenbr); //!< Triangulate the face using CGeomInfo information
    bool GetNormal(const CGeomInfo *, C3DVector& normal, bool normalize = true); //!< Return false if the normal can't be computed (weird face). In such case, a unit vector is returned (1, 0, 0);
    void Get2DCoordinates(const CGeomInfo *, C2DPointList& points2d);
    void GetCenter(const CGeomInfo * info, C3DPoint& center) const;
    void GetPlane(const CGeomInfo *, C4DVector& plane);
 
    // Material
    void SetMaterialID(MaterialID id);
    MaterialID GetMaterialID() const;
 
    // Face ! who are you ?
    double GetCompacityFactor(const CGeomInfo *info) const;
    double Area(const CGeomInfo *info) const;
    bool IsPlane(const CGeomInfo *);
    bool IsConvex(const CGeomInfo *);
 
protected:
    void Get2DCoordinates(CTriangulateFaceHelper* helper, C2DPointList& points2d);
 
};
 
template<typename TYPE> bool RayIntersectsTriangleTUV(const C3DTPoint<TYPE>& orig, const C3DTVector<TYPE>& dir, const C3DTPoint<TYPE>& v0, const C3DTVector<TYPE>& v01, const C3DTVector<TYPE>& v02, double tuv[], bool allowBothDir = false) // orig + dir*tuv[0] is the point that hit the face
{
    C3DTVector<TYPE> h = dir ^ v02; // note: dir must not be (0, 0, 0)
    double det = v01 * h;
 
    // ray and triangle are parallel if det is close to 0
    if (abs(det) < FLOAT_EPSILON3)
        return false;
 
    double invDet = 1 / det;
 
    C3DTVector<TYPE> tvec(v0, orig);
    tuv[1] = invDet * (tvec * h);
 
    if (tuv[1] < 0.0 || tuv[1] > 1.0)
        return false;
 
    C3DTVector<TYPE> qvec = tvec ^ v01;
    tuv[2] = invDet * (dir * qvec);
 
    if (tuv[2] < 0.0 || tuv[1] + tuv[2] > 1.0)
        return(false);
 
    // at this stage we can compute t to find out where
    // the intersection point is on the line
    tuv[0] = invDet * (v02 * qvec);
    if (tuv[0] >= 0.0) // 12/21: was > FLOAT_EPSILON3, but if orig = v0, v1 or v2 the procedure returns false...
        return true;
    else // this means that there is a line intersection
         // but not a ray intersection
        return allowBothDir;
}
 
template<typename TYPE> bool RayIntersectsTriangle(const C3DTPoint<TYPE>& orig, const C3DTVector<TYPE>& dir, const C3DTPoint<TYPE>& v0, const C3DTVector<TYPE>& v01, const C3DTVector<TYPE>& v02, C3DTPoint<TYPE>* hitPt = NULL, bool allowBothDir = false)
{
    double tuv[3];
    if (RayIntersectsTriangleTUV(orig, dir, v0, v01, v02, tuv))
    {
        if (hitPt)
            *hitPt = orig + dir * tuv[0];
 
        return true;
    }
 
    return false;
}
 
 
template<typename TYPE>
bool IsInTriangle(const C3DTPoint<TYPE>& refpt, const C3DTPoint<TYPE>& pt1, const C3DTPoint<TYPE>& pt2, const C3DTPoint<TYPE>& pt3)
{
    int sign12, sign23, sign31;
    C3DTVector<TYPE> vect12, vect23, vect31, vect1h, vect2h, vect3h;
    C3DTPoint<TYPE> cross12_1p, cross23_2p, cross31_3p;
 
    // First, a quick bounding-box test:                               
    // If P is outside triangle bbox, there cannot be an intersection. 
 
#define MIN3(a,b,c) ((((a)<(b))&&((a)<(c))) ? (a) : (((b)<(c)) ? (b) : (c)))
#define MAX3(a,b,c) ((((a)>(b))&&((a)>(c))) ? (a) : (((b)>(c)) ? (b) : (c)))
    if (refpt.x > MAX3(pt1.x, pt2.x, pt3.x)) return FALSE;
    if (refpt.y > MAX3(pt1.y, pt2.y, pt3.y)) return FALSE;
    if (refpt.z > MAX3(pt1.z, pt2.z, pt3.z)) return FALSE;
    if (refpt.x < MIN3(pt1.x, pt2.x, pt3.x)) return FALSE;
    if (refpt.y < MIN3(pt1.y, pt2.y, pt3.y)) return FALSE;
    if (refpt.z < MIN3(pt1.z, pt2.z, pt3.z)) return FALSE;
 
    // For each triangle side, make a vector out of it by subtracting vertexes; 
    // make another vector from one vertex to point P.                          
    // The crossproduct of these two vectors is orthogonal to both and the      
    // signs of its X,Y,Z components indicate whether P was to the inside or    
    // to the outside of this triangle side.                                    
 
    /* 10/22: to be tested. https://github.com/erich666/GraphicsGems/blob/master/gemsiii/triangleCube.c
      the old version of SIGN3 shows some numerical instability, and is improved
      by using the NEW_SIGN3_CODE that follows */
    #ifdef NEW_SIGN3_CODE
        #define SIGN3_EPS 10e-5
        #define SIGN3( A ) \
                      ((((A).x < SIGN3_EPS) ? 4 : 0) | (((A).x > -SIGN3_EPS) ? 32 : 0) | \
                       (((A).y < SIGN3_EPS) ? 2 : 0) | (((A).y > -SIGN3_EPS) ? 16 : 0) | \
                       (((A).z < SIGN3_EPS) ? 1 : 0) | (((A).z > -SIGN3_EPS) ? 8 : 0))
    #else
        #define SIGN3( A ) ((((A).x<0)?4:0) | (((A).y<0)?2:0) | (((A).z<0)?1:0))
    #endif
 
    vect12.InitFromPoints(pt1, pt2);
    vect1h.InitFromPoints(pt1, refpt);
    if (vect1h.x < PRECISION_LIMIT && vect1h.y < PRECISION_LIMIT && vect1h.z < PRECISION_LIMIT) // refpt is confused with pt1
        return true;
    cross12_1p = vect12 ^ vect1h;
    sign12 = SIGN3(cross12_1p);      // Extract X,Y,Z signs as 0...7 integer 
 
    vect23.InitFromPoints(pt2, pt3);
    vect2h.InitFromPoints(pt2, refpt);
    if (vect2h.x < PRECISION_LIMIT && vect2h.y < PRECISION_LIMIT && vect2h.z < PRECISION_LIMIT) // refpt is confused with pt1
        return true;
    cross23_2p = vect23 ^ vect2h;
    sign23 = SIGN3(cross23_2p);
 
    vect31.InitFromPoints(pt3, pt1);
    vect3h.InitFromPoints(pt3, refpt);
    if (vect3h.x < PRECISION_LIMIT && vect3h.y < PRECISION_LIMIT && vect3h.z < PRECISION_LIMIT) // refpt is confused with pt1
        return true;
    cross23_2p = vect23 ^ vect2h;
    cross31_3p = vect31 ^ vect3h;
    sign31 = SIGN3(cross31_3p);
#undef SIGN3
#undef SIGN3_EPS
 
    // If all three crossproduct vectors agree in their component signs,  
    // then the point must be inside all three.                           
    // P cannot be FALSE all three sides simultaneously.                
  
    /* this is the old test; with the revised SIGN3() macro, the test is modified. */
#ifdef NEW_SIGN3_CODE
    return ((sign12 & sign23 & sign31) == 0) ? false : true;
#else
    if ((sign12 == sign23) && (sign23 == sign31))
        return true;
    else
        return false;
#endif
}
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_3DFACE_H__CA6BC29D_FAC2_11D1_A0DE_000000000000__INCLUDED_)