3DGeomObject.h

Go to the documentation of this file.

//! @file 3DGeomObject.h
//! The file contains definition related to C3DGeomObject which is the common object type for any geometrical object
//!
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_3DGEOMOBJECT_H__31D6A935_B14E_11D2_A1E5_000000000000__INCLUDED_)
#define AFX_3DGEOMOBJECT_H__31D6A935_B14E_11D2_A1E5_000000000000__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "3DBaseObject.h"
#include "3DBBox.h"
#include "MaterialMap.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
//! @enum SUBOBJECT_MODE
//! @brief Mode defining the subobject to return for C3DGeomObject::SubOject 
typedef enum SUBOBJECT_MODE XEnumType(unsigned int)
{
    SUBOBJECT_NONE = 0x00,
    SUBOBJECT_FACE_EQUAL = 0x01, //!< The returned subobject will contain faces which have the specified number of index
    SUBOBJECT_FACE_NOTEQUAL = 0x02, //!< The returned subobject will contain faces which have less than the specified number of index
    SUBOBJECT_FACE_GREATER = 0x03, //!< The returned subobject will contain faces which have more than specified number of index
} SUBOBJECT_MODE;
typedef enum SUBOBJECT_MODE XEnumType(unsigned int) {…};
 
//! @enum GENNORMAL_MODE
//! @brief Flags for C3DGeomObject::GenerateNormals
typedef enum GENNORMAL_MODE
{
    GENNORMAL_NONE = 0x00,
    GENNORMAL_ALL_FACES = 0x01, //!< Generate normals for the whole object (this flag implies GENNORMAL_INCOMPLETE_FACE_ONLY)
    GENNORMAL_INCOMPLETE_FACE_ONLY = 0x02, //!< Generates normals for faces that are incomplete (one of whose points has the POINT_IS_UNUSED flag)
    GENNORMAL_PER_VERTEX = 0x04, //!< Generate per vertex normal (CPointNormalChannel smooth normals)
    GENNORMAL_PER_FACE = 0x08, //!< Generate per face normal (CFaceNormalChannel flat normals)
    GENNORMAL_SPEC_CHANNEL = 0x10, //!< Generate a spec normal channel. GENNORMAL_ALL_FACES or GENNORMAL_INCOMPLETE_FACE_ONLY must used
} GENNORMAL_MODE;
typedef enum GENNORMAL_MODE {…};
 
class C3DConcatenateFilter;
class CMapChannelID;
 
//! @class C3DGeomObject
//! @brief This is the base class for any object containing geometry (curve, polygonal object, patch...)
//! @details Such kind of objects have a C3DPointList and/or C3DFaceList and some additional channel information.
//! Cf. @ref OBJECTS to get more details on objects and particularly C3DGeomObject.
class DLL_3DFUNCTION C3DGeomObject : public C3DBaseObject
{
    DECLARE_SERIAL_XOBJECT(C3DGeomObject);
 
    friend CGeomInfo;
 
public:
    //! @enum GENNORMAL_MODE
    //! @brief Flags defining the rendering face mode
    typedef enum  faceModeEnum XEnumType(unsigned int)
    {
        FACE_DEFAULT_MODE = 0,
        SINGLE_SIDE,
        DOUBLE_SIDE,
    } faceModeEnum;
 
    typedef enum  weldMode XEnumType(unsigned int)
    {
        WELD_NONE = 0, //!< Any points could be welded
        WELD_SRC_CANT_HAVE_FLAGS = 0x01, //!< A point will not move if it has the specified flags
        WELD_SRC_MUST_HAVE_FLAGS = 0x02, //!< A point will move only if it has the specified flags
        WELD_TARGET_CANT_HAVE_FLAGS = 0x04, //!< A point can't be a target if it has the specified flags (a target is a point that can be welded to)
        WELD_TARGET_MUST_HAVE_FLAGS = 0x08, //!< A point can be a target only if it has the specified flags 
    } WeldMode;
    typedef enum  weldMode XEnumType(unsigned int) {…};
 
    C3DGeomObject();
    C3DGeomObject(C3DPointList *points, C3DFaceList *faces = NULL, CDependentChannels *channels = NULL); //!< Creates a new C3DGeomObject which uses provided points, faces and channels. These data will be released by the object when it is destroyed
    virtual ~C3DGeomObject();
 
    virtual void Serialize( CXArchive& ar );
 
    int GetPointNbr() const; //!< Return the object point number
    int GetFaceNbr() const; //!< Return the object face number
 
    //! @details Computes the bounding box, on different way. 
    //! BBOX_FACES or BBOX_POINTS must be at least set, depending on wether you want a bounding box on points, or on faces. elmtflags can be optionnaly used to ignore points or faces based on their attributes (hidden face...)
    //! @param bboxflags is combination of BBOX_MODE flags. BBOX_FACES or BBOX_POINTS must be at least set, depending on wether you want a bounding box on points, or on faces.
    //! @param elmtflags is one or more POINT_PROPERTIES or FACE_PROPERTIES flags. elmtflags can be optionnaly used to ignore some points or some faces based on their attributes (hidden face...)
    //! @param node The reference node must be provided if BBOX_EXACT is set.
 
    //! @return If successful, it returns true with point1 and point2 containing the required bounding box limits.
    bool GetBoundingBox(C3DPoint& point1, C3DPoint& point2, unsigned int bboxflags, unsigned int elmtflags = 0, bool set = false, const C3DSceneNode *node = NULL);
    //! @see C3DGeomObject::GetBoundingBox
    //! @return If successful, it returns true with bbox containing the required bounding box.
    bool GetBoundingBox(C3DBBox& bbox, unsigned int bboxflags, unsigned int elmtflags = 0, bool set = false, const C3DSceneNode* node = NULL);
 
    bool GetCG(C3DPoint& point);
 
    //! @name Face smoothing
    //! these methods does not generates normals, they only predefined the smooth angle to be used when point normals are generated.
    //! To generates point normals, use CPointNormalChannel *GetPointNormalChannel() or GenerateNormals
    //! @{
    void SetSmoothAngle(float radianAngle); //!< Set the smooth angle for the specific object. It is used, for example, when calling GetPointNormalChannel() to generate normal breaks.
    float GetSmoothAngle(bool *globalRadianAngle = NULL) const; //!< Get the smooth angle in radian. If object has no specific angle, it will return the C3DScene::GetSmoothAngle. globalRadianAngle, if provided, is set to true, if the object used the global scene smooth angle.
    void SetSmoothMode(NormalSmoothMode mode); //!< Set way normals are generated. Cf. NormalSmoothMode to learn more about the differences.
    NormalSmoothMode GetSmoothMode(bool *globalMode = NULL) const; //!< Get the smooth method used for the object. If object has no specific method, it will return the C3DScene::GetSmoothMode. globalMode, if provided, is set to true, if the object used the global normal mode.
 
    //! @}
 
    //! @name Face culling
    //! @{
    void SetFaceMode(faceModeEnum mode);
    faceModeEnum GetFaceMode(void) const;
 
    //! @}
 
    C3DFaceList* GetFaceList(); //!< Get the object face list
    C3DPointList* GetPointList(); //!< Get the object point list
    CDependentChannels *GetChannels(); //!< Get the object channels
    const CDependentChannels* GetChannels() const; //!< Get const object channels
 
    virtual void SetFaceList(C3DFaceList *faceslist, bool deletePrevious = true); //!< Set the object face list and delete existing one, unless deletePrevious = false
    virtual void SetPointList(C3DPointList *pointslist, bool deletePrevious = true);  //!< Set the object point list and delete existing one, unless deletePrevious = false
    virtual void SetChannels(CDependentChannels *channels, bool deletePrevious = true);  //!< Set the object channellist and delete existing one, unless deletePrevious = false
 
    void FreeExtra(); //!< Release any extra memory attached to the object
 
    //! @name Channel information
    //! @{
    CChannel *GetChannelByID(ChannelID id, Channel3DType type);
    CChannel *GetChannelByIndex(int index, Channel3DType type = CHANNEL_TYPE_UNDEFINED, bool onlyValid = true);
    CPointNormalChannel *GetPointNormalChannel();
    CFaceNormalChannel *GetFaceNormalChannel();
    ChannelID AddChannel(CChannel *channel, ChannelID id = CHANNELID_UNDEFINED); //!< If id = CHANNELID_UNDEFINED, the id is automatically assigned when adding the channel to object channels. If id != CHANNELID_UNDEFINED, the id might be modified if it already exists in object channels
 
    ChannelID GetGlobalVCChannel(float& modulate) const; //!< The global VC channel is a VC channel ID shared by all faces whatever their materials. The method can return CHANNELID_UNDEFINED, because it is usually defined in C3DMaterial::GetVertexColor
    void SetGlobalVCChannel(ChannelID id, float modulate = 1.0f); //!< Set a global VC channel which will superseed, the particular channel defined in the face materials
    ChannelID GetGlobalUVWChannel() const; //!< The global UV channel is a UV channel ID shared by all faces whatever their materials and maps. The method can return CHANNELID_UNDEFINED, because it is usually defined in CMaterialMap::GetChannelID
    void SetGlobalUVWChannel(ChannelID id); //!< Set a global UVW channel which will superseed, the particular channel defined in the face material maps
    bool GenerateUVW(C3DScene *scene, CHANNEL_PROPERTIES tagChannelFlag = CHANNEL_NONE, bool setTagChannelFlag = true); //!< Generate UV when the object contains materials with planar / cylindrical / cubic projection (...)
    ChannelID GlobalizeChannels(C3DScene *scene, bool removeOthers); //!< Gather UVW to a single channel from the different face material maps. If GetGlobalUVWChannel is defined, then the function return the already defined channel. Otherwise, a new channel is created from the different channel referenced by diffuse map and SetGlobalUVWChannel is called with that new channel ID.
 
    //! @}
 
    //! @name Mesh operation
    //! @{
    bool UnifyNormals();
    bool FlipNormals(FACE_PROPERTIES properties = FACE_NONE, bool musthave = true);
    bool GenerateNormals(unsigned int mode = GENNORMAL_PER_VERTEX, NormalSmoothMode smooth = NORMAL_GLOBAL_MODE); //!< Generate normal. Mode is one or a combination of GENNORMAL_MODE (if GENNORMAL_SPEC_CHANNEL is used). Return true if at least one normal has been computed, false if nothing need to be computed
 
    virtual bool MatrixTransform(const C4x4Matrix& matrix); //!< Transform the 3D information with the given matrix. The object should not be instanciated or all instances are modified
 
    //! @brief Weld points which distance is lower than distance specified value.
    //! @param distance the value can be relative or absolute.
    //! * absolute: points which distance is lower than the specified value are welded.
    //! * relative: value is between 0.0 and 1.0 (but can be more) and is a percentage of the lowest object bounding box dimension.
    //! @param absolute the distance specified is absolute. Otherwise di
    //! @param handleChannels allows to weld duplicated value in the corresponding channels. This make a clean operation on the confused value of the corresponding channels. This call CDependentChannels::Weld internally with tolerance = 0.0
    //! * When distance is 0.0, following parameters does not apply
    //! * If distance != 0.0, there is a way to control which points can move and which shouldn't move
    //! @param coupleFlagsNbr 0 if no variadic parameters are specified, the number of variadic parameters otherwise.
    //! @param "variadic parameters" couple of values that defines the flags the points must have to be welded or welded to.
    //! Ie: POINT_IS_SELECTED|POINT_BELONG_TO_BORDER, WELD_SRC_MUST_HAVE_FLAGS|WELD_TARGET_MUST_HAVE_FLAGS, POINT_USER_PROPERTIES1|POINT_USER_PROPERTIES2, WELD_TARGET_MUST_HAVE_FLAGS, POINT_USER_PROPERTIES3, WELD_TARGET_CAN_HAVE_FLAGS, 0
    //! @return true is something was welded, false if nothing changed
    bool Weld3DPoints(double distance, bool absolute, unsigned int handleChannels = ALL_CHANNELS_TYPE, unsigned int coupleFlagsNbr = 0, ...);
    C3DObject *SubObject(int count, SUBOBJECT_MODE mode); //!< Return a sub object from this object based on the faces facecount index number and SUBOBJECT_MODE parameter.
    C3DObject *SubObject(const int *faceIndexes, unsigned int faceCount); //!< Return a sub object from this object using the provided faceIndexes array which has faceCount index.
    int ExplodeIntoIsolatedParts(C3DGeomObjectArray& newobjects);
    bool Concatenate(C3DScene* scene, const C3DGeomObjectArray& object, C3DConcatenateFilter* filter = NULL); //!< Concatenate a set object object with the possibility to exclude some particular faces. Note: If object belong to a node, the coordinates are not transformed in any way. You need to transform them before the call if this is required or use the Concatenate variant with node array
    bool Concatenate(C3DScene *scene, const C3DNodeArray& object, C3DConcatenateFilter *filter = NULL); //!< Concatenate a set of node containing geom object with the possibility to exclude some particular faces. Note: coordinates are transformed taken into account the node transformation.
    bool MergeCoplanarFaces(double radianMaxAngle, unsigned int channels = ALL_CHANNELS_TYPE);
    bool IsTriangular(FACE_PROPERTIES properties = FACE_NONE, bool musthave = true) const;
    bool Triangulate(unsigned int channelType = ALL_CHANNELS_TYPE, FACE_PROPERTIES properties = FACE_NONE, bool musthave = true);
    bool DisconnectBorderFaces(unsigned int channelType = ALL_CHANNELS_TYPE, unsigned int tagPointsFlags = POINT_BELONG_TO_BORDER|POINT_IS_CONFUSED, unsigned int tagFaceFlags = FACE_IS_BORDER|FACE_HAS_CONFUSED_POINTS, CPointGroupGraph *confusedGraph = NULL, bool simulate = false, C3DFaceList *originalChangedFaces = NULL); //!< pointFlags are set for the points that belongs to a seams. This flags cumulates with others
    bool SortFaces(FACE_SORT_MODE sort);
 
    //! @}
 
    // Bindings
#ifdef GEOMOBJECT_SUPPORT_BINDING
    bool HasMaterialBindings() const;
    void AddMaterialBinding(MaterialID id, MaterialID bindto);
    C3DMaterial *GetMaterial(MaterialID id) const; // Get material taking care of the material bindings
    MaterialID BindMaterialID(MaterialID id) const; // Return binded material id
#endif
 
    //! @name Materials used by the object
    //! @{
    bool HasDifferentFrontAndBackUVChannel(const CGeomInfo* info, MapType maptype) const;
    bool HasBackFaceMaterials() const; //!< Return true if the object has different front and back face materials
    const CFBMaterialHashMap *GetFBMaterialsHashMap(); //!< Get material hash (binded if necessary), trigger display
    unsigned int GetMaterialsHashMap(CMaterialHashMap& hashMaterialMap, bool includeBackFace = true, bool reset = true); //!< Return reference material by the object as an association map that contains the materialID and the number of face that are concerned by the material. Some object (ie. curve) without faces can reference a material. In this case, the hash will associate a number of face of 0. Cf. @ref USE_GetMaterialsHashMap "usage sample"
    bool ReplaceMaterials(const CHashMap<MaterialID, MaterialID, MaterialID>& materialMap); //!< Replace front / back face's material which have material key with the corresponding material value, trigger display. Return true if something changed
    bool ReplaceMaterial(MaterialID matid, MaterialID newmatid); //!< Replace face material which have matid with newmatid
 
    //! @}
 
    void ChangeChannelID(C3DScene *scene, CHashMap<CChannelInfo, const CChannelInfo&, CChannelInfo>& channelMap);
 
    void Inherit(const C3DGeomObject& srcObject, unsigned int channeltype, unsigned int channelflags); //!< This methods inherits srcObject points / faces / channel data structure. The object data information is not modified (left empty). It also call InheritFlags
    virtual void InheritFlags(const C3DBaseObject& srcObject, int copyFlags = OBJECT_COPY_DEFAULT); //!< This methods only inherits srcObject flags and custom data. It does not modify the data structure.
    
    virtual bool Update(C3DScene *scene, unsigned int updateMode);
    virtual void Invalidate(unsigned int flags, bool set = true);
    virtual bool InvalidateChannels(unsigned int channelType);
 
    // virtuals
    virtual void Clean(); //!< Clean the object by faces and points which flag have been set to invalid. Update channels accordingly.
    void CleanChannels(ChannelID channelType = CHANNELID_UNDEFINED, bool mustHave = true);
 
    virtual unsigned int GetChecksum(unsigned int checksumFlags = CHECKSUM_ALL) const; //!< Return a value that is a simple way to check if the geometry changed between two calls to the method. Checksum is base on geometry only, not customdata because customdata might have temporary values that does not reflect a content change
 
#ifdef _DEBUG
    virtual void Dump(unsigned int flags);
    unsigned int MemoryStats() const;
#endif
 
private:
    void InitObject(CDependentChannels *refchannels = NULL);
 
protected :
    void ChangeMaterialsChannelID(C3DScene *scene, CHashMap<CChannelInfo, const CChannelInfo&, CChannelInfo>& channelMap);
 
    CChannel *MakeGlobalChannel(CHashTable<CMapChannelID> *&hashChannel, Channel3DType type);
    ChannelID CreateUVWChannel(CMaterialMap *map, MaterialID matid, bool front);
 
    // Virtuals
    virtual bool InternalCopy(C3DBaseObject *&dstObject, int flags = OBJECT_COPY_DEFAULT, C3DObjectCreator *objectCreator = NULL) const;
 
    // Display
    void *bboxCache;
 
    float smooth_angle; // Later : move it to node
    NormalSmoothMode smooth_mode; // Later : move it to node
    faceModeEnum faceMode;
 
    C3DFaceList *faces;
    C3DPointList *points;
 
    CDependentChannels *channels;
    ChannelID uvwID, vcID;
    float vcModulate;
 
    // Binds
#ifdef GEOMOBJECT_SUPPORT_BINDING
    typedef CHashMap<MaterialID, MaterialID, MaterialID> CMaterialBindingMap;
    CMaterialBindingMap materialBindings;
    CMaterialHashMap bindedMaterialHash;
#endif
};
class DLL_3DFUNCTION C3DGeomObject : public C3DBaseObject {…};
 
#if 0
// This class free an object automatically
class C3DObjectDestructor
{
public:
    C3DGeomObject *object;
 
    C3DObjectDestructor()
    {
        object = NULL;
    }
 
    virtual ~C3DObjectDestructor()
    {
        xDelete(object);
    }
 
    void Attach(C3DGeomObject *refobject)
    {
        this->object = refobject;
    }
};
#endif
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_3DGEOMOBJECT_H__31D6A935_B14E_11D2_A1E5_000000000000__INCLUDED_)