Face.h

Go to the documentation of this file.

//! @file Face.h
//! CFace class definition which is the base class for any kind of face
//!
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_FACE_H__CA6BC29D_FAC2_11D1_A0DE_000000000000__INCLUDED_)
#define AFX_FACE_H__CA6BC29D_FAC2_11D1_A0DE_000000000000__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "Collection.h"
#include "Point.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
#define POINT_NOT_BELONG_TO_FACE -1
#define EDGE_NOT_BELONG_TO_FACE -1
 
typedef enum XEnumType(unsigned int)
{
    FACE_UNCHANGE = 0x00,
    FACE_CHANGE = 0x01,
    FACE_INVALID = 0x02,
    FACE_DUPLICATED_INDEX = 0x04,
} FACERESULT;
 
typedef enum XEnumType(unsigned int)
{
    CONDITION_BELONG_TO_NONE = 0x00,
    CONDITION_BELONG_TO_SOME = 0x01,
    CONDITION_BELONG_TO_ALL = 0x02,
} FLAGRESULT;
 
//! @enum FACE_PROPERTIES
//! @brief Face flags used by any classes that inherit from CFace (C3DFace, CUVWFace...)
typedef enum FACE_PROPERTIES XEnumType(unsigned int)
{
    FACE_NONE = 0x00,
 
    //!< These flags can be used whatever the face class
    FACE_IS_INVALID = 0x01, //!< This flag is used when a face a less than 3 indexes or when it is tagged invalid. Geometric faces that have this flag are removed during cleaning operation. Channel face are kept, but the flag is converted to FACE_IS_UNUSED during cleaning operation.
    FACE_IS_UNUSED = 0x02,  //!< This flag is to be used in a dependent channel, meaning that the face should be ignored and does not contain data.
    FACE_IS_HIDDEN = 0x04,
    FACE_IS_HOLE = 0x08,
    FACE_IS_SINGLE_SIDED = 0x10, //!< Force single side display (cannot be used with FACE_IS_DOUBLE_SIDED)
    FACE_IS_DOUBLE_SIDED = 0x20, //!< Force double side display
    FACE_IS_SELECTED = 0x40,
 
    //!< Face computed properties
    FACE_IS_BORDER = 0x1000,
    FACE_HAS_COPLANAR_NEIGHBOURG = 0x2000,
    FACE_HAS_CONFUSED_POINTS = 0x4000,
    FACE_IS_TEMP_SELECTED = 0x8000, //!< used by some algorithm to tag some faces. It must be reset to FALSE each time you need to use it.
 
    FACE_USER_SELECTED = 0x10000, //!< Flag used for interacting with point list. This is a helper to keep FACE_IS_SELECTED flags is interaction canceled.
 
    FACE_USER_PROPERTIES1 = 0x01000000,
    FACE_USER_PROPERTIES2 = 0x02000000,
    FACE_USER_PROPERTIES3 = 0x04000000,
    FACE_USER_PROPERTIES4 = 0x08000000,
} FACE_PROPERTIES;
 
class CFacePropertyMethods;
//! @class CFacePropertyData
//! @brief CFacePropertyData is the main data chunk of CFaceList which consists of storing the flags.
//! @details It is overriden by C3DFacePropertyData in C3DFaceList
class CFacePropertyData
{
    friend CFacePropertyMethods;
    friend CFaceList;
    friend CFace;
 
protected:
    unsigned int flags;
 
    CFacePropertyData();
};
 
inline CFacePropertyData::CFacePropertyData()
{
    flags = FACE_NONE;
}
 
//! @class CFace
//! @brief A CFace contains the information related to a given face in a CFaceList.
//! @details CFace is most of the time built from CFaceList::GetFace method. It represents a single face of this list at the specified index.
//! CFace is the base class for more specific classes C3DFace, CUVWFace...\n
//! It contains an array of indexes that refers to CPointList.
//! @note
//! CFaces indexes can be modified or resized but do not forget that they are part of the whole CFaceList, which is in a single memory block.\n
//! Resizing faces (especially if indexes are added) can lead to numerous memory reallocations and loss of performance.\n
//! The CFaceList class contains a number of methods for pre-allocating memory, so that a call to SetSize does not lead to inappropriate memory reallocations.
class CDataChunk;
class DLL_3DFUNCTION CFace : protected CCollectionElement<int, unsigned short>
{
    friend CFaceList;
 
protected:
    CFaceList *faces;
    CFacePropertyData *prop;
 
public:
    using CCollectionElement<int, unsigned short>::Reset;
    using CCollectionElement<int, unsigned short>::IsEmpty;
    using CCollectionElement<int, unsigned short>::GetSize;
    using CCollectionElement<int, unsigned short>::GetData;
    using CCollectionElement<int, unsigned short>::operator [];
    using CCollectionElement<int, unsigned short>::GetAt;
    using CCollectionElement<int, unsigned short>::SetAt;
 
    CFace();
 
    // Face info
    unsigned int GetFaceIndex() const;
    unsigned int GetFlags() const;
    void SetFlags(unsigned int flags);
    bool IsFlagSet(FACE_PROPERTIES) const;
    bool IsOneFlagSet(int flag) const;
    void SetFlag(FACE_PROPERTIES, bool set);
    void SetFlags(unsigned int flags, bool set);
    void Inherit(const CFace& srcface); //!< Inherit srcface chunks (and so flags and others properties), but don't copy the srcface indexes
    bool Copy(const CFace& srcface);
    bool Copy(unsigned int srcindex);
 
    // Points index functions
    int *SetSize(int size, FACE_PROPERTIES invalidFlag = FACE_IS_INVALID); //!< Set the number of indexes for the face. If size < 3, then invalidFlag flag is set, if size >= 3 the flag is removed.. For channel flags, FACE_IS_UNUSED should be used to keep the same number of faces between 3d faces and channel faces, if the matching 3d face is not set to invalid on a clean operation
    int ReplaceIndex(int oldindex, int newindex);
    bool CompareIndexes(const CFace& refface, bool allowIndexShift) const;
    int AddIndex(int);
    bool RemoveIndex(int);
    void SetTriangle(int pointindex1, int pointindex2, int pointindex3);
    void SetQuadrangle(int pointindex1, int pointindex2, int pointindex3, int pointindex4);
    void Flip();
 
    // Face ! who are you ?
    bool IsOnePointFlagSet(const CGeomInfo *info, unsigned int pointPropertiesFlags, bool set); //!< check if one point has one of the pointPropertiesFlags set or unset (call IsPointFlagSet internally)
    FLAGRESULT IsPointFlagSet(const CGeomInfo *info, unsigned int pointPropertiesFlags, bool set);  //!< check how many points have one of the pointPropertiesFlags set or unset (call IsPointFlagSet internally)
    void SetPointFlag(const CGeomInfo *info, unsigned int pointPropertiesFlags, bool set);
    int IsFacePoint(int pointindex); //!< Check if point index belong to face. Return the index position of this pointindex or POINT_NOT_BELONG_TO_FACE
    int GetPrevIndex(int offset) const;
    int GetNextIndex(int offset) const;
    int IsFaceEdge(int pt1, int pt2, bool sameOrder);
    bool IsTriangular();
 
    // Others
    void GetCenter(const CGeomInfo *info, C4DPoint& center) const;
    void *GetDataChunk(unsigned int id) const;
    SIZET GetSizeOfData(unsigned int id) const;
};
 
///////////////////////////////////////////////////////////////////////////////////
// Inline implementation
 
inline CFace::CFace()
{
    faces = NULL;
    prop = NULL;
}
 
inline unsigned int CFace::GetFaceIndex() const
{
    return GetEntryIndex();
}
 
inline unsigned int CFace::GetFlags() const
{
    return prop->flags;
};
 
inline void CFace::SetFlags(unsigned int flags)
{
    prop->flags = flags;
};
 
inline void CFace::SetFlag(FACE_PROPERTIES flag, bool set)
{
    if (set)
        prop->flags |= flag;
    else
        prop->flags &= ~flag;
}
 
inline void CFace::SetFlags(unsigned int newflags, bool set)
{
    if (set)
        prop->flags |= newflags;
    else
        prop->flags &= ~newflags;
}
 
inline bool CFace::IsFlagSet(FACE_PROPERTIES flag) const
{
    return ((prop->flags & flag) == flag);
}
 
inline bool CFace::IsOneFlagSet(int flag) const
{
    XASSERT(flag != FACE_NONE); // This does not allow to test this case
    return ((prop->flags & flag) != 0);
}
 
// Return the next point index, giving a face offset
inline int CFace::GetNextIndex(int offset) const
{
    int size;
    const int *pts_data = GetData(size);
    XASSERT(offset >=0 && offset < size);
    return pts_data[(offset+1) % size];
}
 
// Return the prev point index, giving a face offset
inline int CFace::GetPrevIndex(int offset) const
{
    int size;
    const int *pts_data = GetData(size);
    XASSERT(offset >=0 && offset < size);
    return pts_data[(size+offset-1) % size];
}
 
inline int* CFace::SetSize(int size, FACE_PROPERTIES invalidFlag)
{
    SetFlag(invalidFlag, size < 3);
    return CCollectionElement<int, unsigned short>::SetSize(size);
}
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_FACE_H__CA6BC29D_FAC2_11D1_A0DE_000000000000__INCLUDED_)