3DFaceList.h

Go to the documentation of this file.

//! @file 3DFaceList.h
//!
//! @brief C3DFaceList class definition which is a list of C3DFace
//!
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_3DFACELIST_H__CA6BC2A4_FAC2_11D1_A0DE_000000000000__INCLUDED_)
#define AFX_3DFACELIST_H__CA6BC2A4_FAC2_11D1_A0DE_000000000000__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "BitArray.h"
#include "3DBBox.h"
#include "FaceList.h"
#include "3DPointList.h"
#include "3DFace.h"
#include "DependentChannels.h"
#include "MaterialMap.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
//! @class FBMaterialID
//! @brief This class handles two MaterialID that simplifies operation on faces which have front and back materials.
//! For example Sketchup format use intensively that kind of faces, and FBMaterial is a simple way to know if a face IsSingleMaterial, or if it has different front and back materials. 
class FBMaterialID
{
public:
    MaterialID frontID;
    MaterialID backID;
 
    FBMaterialID()
    {
        frontID = backID = MATERIAL_UNDEFINED;
    }
 
    FBMaterialID(MaterialID front, MaterialID back = MATERIAL_UNDEFINED)
    {
        frontID = front;
        backID = back;
    }
 
    inline bool operator==(FBMaterialID mat) const
    {
        if (frontID == mat.frontID && backID == mat.backID)
            return true;
 
        return false;
    }
 
    inline bool operator!=(FBMaterialID mat) const
    {
        if (frontID != mat.frontID || backID != mat.backID)
            return true;
 
        return false;
    }
 
    inline bool IsUndefined() const
    {
        if (frontID == MATERIAL_UNDEFINED && backID == MATERIAL_UNDEFINED)
            return true;
 
        return false;
    }
 
    inline bool IsFrontDefined() const
    {
        return (frontID != MATERIAL_UNDEFINED);
    }
 
    inline bool IsBackDefined() const
    {
        return (backID != MATERIAL_UNDEFINED);
    }
 
    inline bool IsSingleMaterial() const // Return true if front material is the same than back material or if there is no back material. Note: this does not take into account the fact that this single material might have different front and back UV
    {
        return (frontID == backID) || (!IsBackDefined());
    }
};
 
template <> class CHashMethods<FBMaterialID>
{
public:
    static inline bool HashCompare(const FBMaterialID& mat1, const FBMaterialID& mat2)
    {
        if (mat1.frontID != mat2.frontID)
            return false;
 
        if (mat1.backID != mat2.backID)
            return false;
 
        return true;
    }
 
    static inline unsigned int HashValue(const FBMaterialID& hash)
    {
        return CHashMethods<MaterialID>::HashValue(hash.frontID)+CHashMethods<MaterialID>::HashValue(hash.backID);
    }
};
 
//! @class CFBMaterialHashMap
//! @brief This class gets an object material hash. It returns front and back material pair.
//! @Note if we have a face #1 [Mat #1, Mat #2] and a face #2 [Mat #1, Mat #3] we will get 2 entries with (#1-#2, 1), (#1-#3, 1)
class DLL_3DFUNCTION CFBMaterialHashMap : public CHashMap<FBMaterialID, FBMaterialID, unsigned int>
{
    friend C3DFaceList;
 
protected:
    mutable bool hasBackMaterial;
 
public:
    CFBMaterialHashMap();
 
    unsigned int GetFrontHash(CMaterialHashMap& map, bool reset = true, bool removeUndefinedMaterial = true) const; // Get the front material hash map and return the number of front material faces
    unsigned int GetBackHash(CMaterialHashMap& map, bool reset = true, bool removeUndefinedMaterial = true) const;  // Get the back material hash map and return the number of back material faces
    unsigned int GetFrontBackHash(CMaterialHashMap& map, bool reset = true, bool removeUndefinedMaterial = true) const; // Get the front and back material hash map and return the number of material that belong to front or back faces. Note: if we have a face #1 [Mat #1, Mat #2] and a face #2 [Mat #1, Mat #3] we will get 3 entries with (#1, 2), (#2, 1) (#3, 1)
 
    unsigned int ReplaceFrontMaterial(MaterialID matid, MaterialID newmatid); // Replace all materials that have front matid by front newmatid material. Return the number of front materials changed
    unsigned int ReplaceBackMaterial(MaterialID matid, MaterialID newmatid);  // Replace all materials that have back matid by back newmatid material. Return the number of back materials changed
 
#ifdef _DEBUG
    unsigned int GetFaceCount(MaterialID frontid, MaterialID backid) const; // Return the number of face thta have frontid or backid
    static unsigned int GetFaceCount(const CMaterialHashMap& map); // Return the number of face concerned by the material hash
#endif
};
 
class C3DFacePropertyMethods : public CFacePropertyMethods
{
    DECLARE_SERIAL_XOBJECT(C3DFacePropertyMethods);
 
    SIZET GetSizeof() const;
    ElementType GetType() const;
    void ConstructElement(void* pNewData);
 
#ifdef _DEBUG
    void Dump(const void* data) const
    {
        XTRACE(_T("Flags: %d - MaterialID : %d\n"), ((C3DFacePropertyData*)data)->flags, ((C3DFacePropertyData *)data)->materialid);
    };
#endif
};
 
inline SIZET C3DFacePropertyMethods::GetSizeof() const
{
    return sizeof(C3DFacePropertyData);
}
 
inline ElementType C3DFacePropertyMethods::GetType() const
{
    return MAKE_CUSTOM_ID('3', 'D', 'F', 'A');
}
 
inline void C3DFacePropertyMethods::ConstructElement(void* pNewData)
{
    xConstruct(C3DFacePropertyData, pNewData);
}
 
typedef enum FaceGridFlags XEnumType(unsigned int)
{
    FACEGRID_NONE = 0x00,
 
    // Method that will be called 
    FACEGRID_CACHE_FOR = 0x0FF,
    FACEGRID_CACHE_FOR_RAYCAST = 0, // Default method
    FACEGRID_CACHE_FOR_GETCLOSESTFACE,
        
    // Parameters
    FACEGRID_MULTITHREADED = 0x100, // the grid will be called in concurrently in different thread
    FACEGRID_REMOVE_DUPLICATED_FACES = 0x200, // Fast removal of duplicated faces in the graph (face that have same indexes. As a consequence, only one of those duplicated faces are added to the grid)
    FACEGRID_FILL_FULL_BBOX = 0x400, // This is the and original standard filling method (all face bbox cells are filled). Otherwise only cells belonging to the face plane are filled.
    FACEGRID_IGNORE_NODE_TRANSFORM = 0x800, // If a node is provided, does not take care of the node transform
 
#ifdef _DEBUG
    FACEGRID_DEBUG = 0x10000,
#endif
} FaceGridFlags;
 
//! @enum RayCastFlags
//! This enum gives a control on the faces handled by C3DFaceList::GetRayCastFace and information returned.
typedef enum RayCastFlags XEnumType(unsigned int)
{
    RAYCAST_DEFAULT = 0x00,
    RAYCAST_CHECK_BOTHDIR = 0x01, //!< Test ray cast in both direction
    RAYCAST_TUV_COORDINATE = 0x02, //!< hitPoint(x, y, z) contains the (t, u, v) coordinates of the found intersection. We can compute the hitPoint in 2 way : hitPoint = eye + t * normal or hitPoint = (1-u-v) * p0 + u * p1 + v * p2 where p0, p1, p2 are the triangle point. Note that if RAYCAST_CHECK_BOTHDIR and that the normal have been flipped to intersect the face, then t will be negative to correctly compute the hitPoint
    RAYCAST_SAME_DIRECTION = 0x04, //!< The provided direction and the normal of the face must have the same direction
    RAYCAST_OPPOSITE_DIRECTION = 0x08, //!< The provided direction and the normal of the face must have the opposite direction
#ifdef _DEBUG
    RAYCAST_DEBUG = 0x1000, //!< internal: Debug ray cast
#endif
} RayCastFlags;
 
//! @class C3DFaceGridMap
//! @brief C3DFaceGridMap is initialized by C3DFaceList::GetFaceGridMap.
//! @details It allows to perform fast ray casting or retrieve the closest face giving a point.
//! Giving a point, it return a face index list of the faces which are in the voxel where is located the point.
class C3DFaceGridMap : public C3DPointGridMap, public CInstanciatedObject
{
    friend C3DFaceList;
 
protected:
    mutable CXCriticalSection threadLock;
    unsigned int flags;
    unsigned int facesize; // The face list number of faces, needed to initializing ThreadInfo through BeginThread
    C4x4Matrix mat; // A transformation matrix
    C3DBBox bbox; // The bounding box containing the datas (eventually transformed)
    C3DPointI cells; // cells number in x, y, z dimensions
 
#ifdef _DEBUG
    unsigned int beginThreadCount;
#endif
 
    typedef struct ThreadInfo
    {
        CBitArray checkedFaces; // Speedup GetClosestFace by avoiding multiple allocation
        CXArray<int> checkedIndexes;
    } ThreadInfo;
 
    CHashMap<xThreadID, xThreadID, ThreadInfo *> threadInfo;
 
    unsigned int ThreadCount() const;
    bool ThreadIsInitialized() const;
 
public:
    C3DFaceGridMap(CGeomInfo* info, unsigned int faceGridFlags); //!< Init grid. info contains points and faces list. voxelCountMultiplicationFactor multiply the default number of grid voxel.
    virtual ~C3DFaceGridMap();
 
    ThreadInfo *BeginThread(bool forceSingleThread = false); //!< Parallel support for GetClosestFace, GetRayCastFace, GetRayCastFace2
    void EndThread();
 
    unsigned int GetFlags() const; //!< return flags used for creating the C3DPointGridMap
    C3DBBox GetBBox() const; //!< Return the bounding box of the face list using for creating the grid map
    const C4x4Matrix& GetTransform() const; //!< Return the matrix used to transform the point of the face grid map
    unsigned int GetCellNbr() const; //!< Return the total number of cells that have been defined automatically depending on the input face list
 
#ifdef _DEBUG
    void Dump() const;
    unsigned int ThreadInitializationCount() const { return beginThreadCount; }
#endif
};
 
//! @class C3DFaceList
//! @brief C3DFaceList class which implement a list of C3DFace. Each face contains indexes to 3D points stored in C3DPointList class.
//! Look at CFaceList base class to get more information.
//!
class DLL_3DFUNCTION C3DFaceList : public CFaceList
{
public:
    // using CFaceList::operator=;
    DECLARE_SERIAL_XOBJECT(C3DFaceList);
 
    //! @brief Create a new face list. When srcFaces is provided, the data structure (datachunks) is inherited but the face list is created empty
    C3DFaceList(C3DFaceList *srcFaces = NULL);
    virtual ~C3DFaceList(); //!< Use CFace::Delete should be used because there can be several references to the face list. This does not occurs if C3DFaceList is created on the stack.
 
    static C3DFaceList *Create(C3DFaceList *srcFaces = NULL); //!< Allocates and creates an empty set of 3d faces. Use C3DFaceList::Delete to delete it
 
    virtual CFace *CreateFace() const //!< @brief use ReleaseFace(CFace *) to delete created face
    {
        return xNew(C3DFace);
    };
 
    //! @name Face information
    //! Various information about the face
    //!
    //! @{
    // void FlipFaces(const CGeomInfo *info, bool invertSpecNormal = true); // Reverse the index order for all faces and all the corresponding channel faces. Optionally set spec normal channels vectors to opposite dir
    bool GetBoundingBox(const CGeomInfo *info, C3DPoint& min, C3DPoint& max, unsigned int faceFlags = FACE_NONE, bool set = true, C4x4Matrix *matrix = NULL); //!< points are transformed by matrix if any provided
    bool GetBoundingBox(const CGeomInfo *info, C3DBBox& bbox, unsigned int faceFlags = FACE_NONE, bool set = true, C4x4Matrix *matrix = NULL); //!< points are transformed by matrix if any provided
    bool UnifyNormals(CGeomInfo *info, CBitArray& flippedFaces);
    double GetDistanceToFace(CGeomInfo *info, unsigned int index, const C3DPoint& pt); //!< Get the distance from face index to the given pt. Calculate the projection on the face or on the closest edge. The face can be both triangular or quadrangular
    double GetDistanceToFacePlane(CGeomInfo *info, unsigned int index, const C3DPoint& pt, bool absoluteValue = true); //!< Get the distance from face index to the face plane. The face can be N-Gon but in this case, we check before that this NGon is planar, which can be slow.
 
    //! @}
 
    //! @name Operations on face
    //! Modify the faces
    //!
    //! @{
    int MergeCoplanarFaces(const CGeomInfo *info, double radianMaxAngle);
    int Triangulate(CGeomInfo *, unsigned int uvwChannel = ALL_CHANNELS_TYPE, FACE_PROPERTIES properties = FACE_NONE, bool musthave = true);
 
    //! @}
 
    //! @name Retrieve quickly a face
    //! Create a C3DFaceGridMap which is a way to quickly find a face
    //!
    //! @{
    unsigned int GetFaceGridMapFlags() const; //!< Return an already computed face grid or null
    C3DFaceGridMap* GetFaceGridMap(bool addReferenceCount = true); //!< Return an already computed map that contains each faces sampled in an integer grid. Pending DeleteFaceGridMap must be called, unless addReferenceCount = false
    C3DFaceGridMap *GetFaceGridMap(CGeomInfo *info, unsigned int faceGridFlags = FACEGRID_NONE); //!< Return or (re-)compute a map that contains each faces sampled in an integer grid, with the given flags. The face list must be triangular, otherwise, returns NULL. Pending DeleteFaceGridMap must be called.
    unsigned int GetClosestFace(CGeomInfo * info, C3DFaceGridMap * faceGridMap, const C3DPointD& pt, double& distance, double maxdistance = HUGE_VAL); //!< Return the closest face index to the point pt. If a face is found distance contains the distance of pt to the face. Otherwise distance = HUGE_VALUE and index INVALID_FACE_INDEX is returned. maxDistance can be used to define a max distance and limite the search, increasing speed.
    unsigned int GetRayCastFace(CGeomInfo* info, C3DFaceGridMap* faceGridMap, const C3DPointD& eye, const C3DVectorD& dir, C3DPointD& hitPoint, unsigned int rayCastFlags = RAYCAST_DEFAULT, bool *oppositeDir = NULL); //!< Return the ray cast face index to the point pt, or INVALID_FACE_INDEX if none.
    void DeleteFaceGridMap();
 
    //! @}
 
    //! @name Sort faces
    //!
    //! @{
    int *Sort(unsigned int sortmode, unsigned int& arraySize, bool& orderChanged); //!< sortmode contains FACE_SORT_MODE flags. arraySize is the size of the returned index array. orderChanged is false if the faces are already sorted (index of the array match index of the faces). orderChanged means nothing if SORT_FRONT_AND_BACK_MATERIAL is set. The method returns a sorted by material array (this does not change the face order itself). arraySize contains the size of the returned array. It is equal to GetSize() or 2*GetSize() depending on the sort mode
    bool Sort(const CGeomInfo *info, unsigned int mode); //!< Sort the face by changing their order; depenging on the front or back face material (SORT_FRONT_AND_BACK_MATERIAL cannot be used)
 
    //! @name Get or modify material used by faces
    //!
    //! @{
    bool ReplaceMaterial(MaterialID matid, MaterialID newmatid); //!< Replace face matid by newmatid and update the material hash map if possible
    unsigned int GetMaterialsHashMap(const CGeomInfo *info, CMaterialHashMap& hashMaterialMap,  bool includeBackFace = true, bool reset = true); //!< Get (MaterialID, facecount) hash. If includeBackFace, the back face material are added to the hash. Return the number of material
    const CFBMaterialHashMap *GetFBMaterialsHashMap(const CGeomInfo *info); //!< Return a ((front MaterialID, back MaterialID), facecount) material id hash
    void DeleteFBMaterialsHashMap(); //!< Free the hash material when no longer needed
 
    // double side material information
    bool HasDifferentFrontAndBackUVChannel(const CGeomInfo* info, MapType type) const; //!< Return true if the object has different front and back UV channels (looking materials front & back UV). The method return false, if back UV is undefined or if front and back channel are the same. A CGeomInfo with object and scene is needed.
    bool HasBackFaceMaterials() const;
    bool RemoveBackFaceMaterials(); //!< Return true if object had back face materials
    void SetBackFaceMaterial(unsigned int index, MaterialID id);
    void SetFaceMaterial(unsigned int index, MaterialID id);
    MaterialID GetFaceMaterial(unsigned int index) const;
    MaterialID GetBackFaceMaterial(unsigned int index, bool getFrontIfNeeded = false) const; //!< getFrontIfNeeded = false return possibly MATERIAL_UNDEFINED. If getFrontIfNeeded  = true, then this value is overriden by front face material
    FBMaterialID GetFBFaceMaterial(unsigned int index, bool getFrontIfNeeded = false) const; //!< getFrontIfNeeded = false return possibly MATERIAL_UNDEFINED. If getFrontIfNeeded  = true, then this value is overriden by front face material
    bool CompareBackAndFrontMaterials(bool deleteBackIfSame, bool checkFrontBackMaterialChannel = false, CGeomInfo *info = NULL); //!< return true if back & front materials are the sames, or if no back materials. deleteBackIfSame = true will delete the extra back face information. checkFrontBackMaterialChannel = true the delete occurs only if channelID is the same for front and back channelID (we might have the same material applied to both side of a face, with different channels) or if 2 differents channels are exactly the same
 
    //! @}
 
    // Update informations
    virtual bool UpdateList();
 
    virtual void RemoveAll();
    C3DFaceList& operator=(const C3DFaceList& reffaces);
    virtual CFaceList& operator=(const CFaceList& reffaces);
 
#ifdef _DEBUG
    unsigned int GetRayCastFaceDebug(CGeomInfo* info, C3DFaceGridMap* faceGridMap, const C3DPointD& eye, const C3DVectorD& dir, C3DPointD& hitPoint, unsigned int rayCastFlags = RAYCAST_DEFAULT, bool* oppositeDir = NULL); // Return the ray cast face index to the point pt, or INVALID_FACE_INDEX if none.
    CXString GetFaceListType() const  { return _T("3D"); };
#endif
 
protected:
    CFBMaterialHashMap *fbMaterialHash;
    C3DFaceGridMap *faceGridMap;
 
    void CreateFBMaterialsHashMap(); // use GetMaterialsHash
 
    int DoTriangulation(const CGeomInfo *info, unsigned int newsize, int internalFlags, FACE_PROPERTIES properties = FACE_NONE, bool musthave = true);
};
 
inline void C3DFaceList::SetFaceMaterial(unsigned int index, MaterialID id)
{
    C3DFacePropertyData *prop = static_cast<C3DFacePropertyData *>(GetMainDataChunk(index));
    prop->materialid = id;
}
 
inline MaterialID C3DFaceList::GetFaceMaterial(unsigned int index) const
{
    C3DFacePropertyData *prop = static_cast<C3DFacePropertyData *>(GetMainDataChunk(index));
    if (prop && !(prop->flags & (FACE_IS_INVALID|FACE_IS_UNUSED)))
        return prop->materialid;
 
    return MATERIAL_UNDEFINED;
}
 
inline MaterialID C3DFaceList::GetBackFaceMaterial(unsigned int index, bool getFrontIfNeeded) const
{
    const CBackFaceMaterialData *data = (const CBackFaceMaterialData *)GetDataChunks().GetData(FACE_BACK_MATERIAL, index);
    if (data)
    {
        if (getFrontIfNeeded && data->matid == MATERIAL_UNDEFINED)
            return GetFaceMaterial(index);
 
        return data->matid;
    }
 
    return getFrontIfNeeded ? GetFaceMaterial(index) : MATERIAL_UNDEFINED; // Invalid material. Use the front face material
}
 
inline FBMaterialID C3DFaceList::GetFBFaceMaterial(unsigned int index, bool getFrontIfNeeded) const
{
    return FBMaterialID(GetFaceMaterial(index), GetBackFaceMaterial(index, getFrontIfNeeded));
}
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_3DFACELIST_H__CA6BC2A4_FAC2_11D1_A0DE_000000000000__INCLUDED_)