3DBaseObject.h

Go to the documentation of this file.

//! @file 3DBaseObject.h
//! @brief C3DBaseObject class which is the common base class for all object types
//
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_3DBASEOBJECT_H__31D6A935_B14E_11D2_A1E5_000000000000__INCLUDED_)
#define AFX_3DBASEOBJECT_H__31D6A935_B14E_11D2_A1E5_000000000000__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "DependentChannels.h"
#include "4x4Matrix.h"
#include "3DPoint.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
// Object custom id
#define OBJECT_REFERENCE_OBJECT     MAKE_CUSTOM_ID('R', 'F', 'O', 'B')
 
#define OBJECT_GUID_CLASS MAKE_CUSTOM_ID('O', 'B', 'J', 'C')
 
//! @enum OBJECT_KINDOF
//! The kind of object. An object has only one kind.\n
//! It is possible to test if an object belong to a given kind using OR operator. Ie. if (kindOf & (OBJECT_MESH|OBJECT_CURVE))
typedef enum OBJECT_KINDOF XEnumType(unsigned int)
{
    OBJECT_UNKNOWN = 0,
 
    // Object kindof return by C3DBaseObject::GetKindOf
    // This allows to cast a C3DBaseObject to another type of object
    OBJECT_MESH = 0x01, //!< C3DObject
    OBJECT_CURVE = 0x02, //!< C3DCurve
    OBJECT_PATCH = 0x04, //!< C3DPatch
    OBJECT_GROUP = 0x08, //!< C3DGroup
    OBJECT_DUMMY = 0x10, //!< C3DDummy
    OBJECT_CAMERA = 0x20, //!< C3DCamera
    OBJECT_LIGHT = 0x40, //!< C3DLight
 
    // Private object type
    OBJECT_PRIVATE_TYPE = 0xFF000000,
    OBJECT_POI_CAMERA = 0x01000000, // C3DPoiCamera = C3DCamera
 
    //!< These flags can be used in C3DScene::GetFirstNode/GetNextNode or to perform a bitwise operation on C3DBaseObject::GetKindOf
    OBJECT_GEOM_WITH_FACES = OBJECT_MESH | OBJECT_PATCH,
    OBJECT_GEOM = OBJECT_GEOM_WITH_FACES | OBJECT_CURVE,
    OBJECT_ALL_KINDOF = (unsigned int)-1, //!< This also include private type for copy and other specific operations
} OBJECT_KINDOF;
 
typedef enum _OBJECT_PROPERTIES XEnumType(unsigned int)
{
    OBJECT_NONE = 0x00,
    OBJECT_IS_INVALID = 0x10,
    OBJECT_RENDER_WIREFRAME = 0x20, // Object is rendered in wireframe only
 
    OBJECT_USER_PROPERTIES1 = 0x01000000, // Specific user properties for specific purposes
    OBJECT_USER_PROPERTIES2 = 0x02000000,
    OBJECT_USER_PROPERTIES3 = 0x04000000,
    OBJECT_USER_PROPERTIES4 = 0x08000000,
} OBJECT_PROPERTIES;
 
//! @enum OBJECT_UPDATE_PROPERTIES
//! Flags used by C3DBaseObject::Invalidate / C3DBaseObject::Update. Depending on the SCENE_NODE_INV flags in a C3DBaseObject::Invalidate call, the method set required OBJECT_UPDATE flags that will be processed when calling C3DBaseObject::Update.\n
//! For example OBJECT_INV_TOPO will flag OBJECT_UPDATE_GEOM. For a C3DPatch object, this will make the subdivided object to be invalidate and recomputed on the Update call.
typedef enum OBJECT_UPDATE_PROPERTIES XEnumType(unsigned int)
{
    OBJECT_INV_FLAGS            = 0xFFFF,
    OBJECT_INV_ALL              = OBJECT_INV_FLAGS,
    OBJECT_INV_GEOM             = 0x0001, //!< Points position or number changed
    OBJECT_INV_TOPO             = 0x0002, //!< Faces indexes size, indexes changes
    OBJECT_INV_FACE_FLAG        = 0x0004, //!< Face properties changed (ie HIDDEN flag of face changed)
    OBJECT_INV_MATERIALS        = 0x0008, //!< Face materials changes
    OBJECT_INV_CHANNELS         = 0x0010, //!< Channel changed, autogenerated channels need to be recomputed...
    OBJECT_INV_MATERIAL_ATTR    = 0x0020, //!< A material related to object changed
    OBJECT_INV_DATA             = 0x0040, //!< Custom data associated to object changed
 
    OBJECT_INV_DISPLAY          = 0x0800, //!< The object drawing should be updated
 
    // This implies some recomputation in the object (Done through C3DBaseObject::Update)
    OBJECT_UPDATE_NONE          = 0x00000000,
    OBJECT_UPDATE_ALL           = 0x0FFF0000,
    OBJECT_UPDATE_FIRST_VALUE   = 0x00010000, //!< For intenal offset
    OBJECT_UPDATE_BBOX          = 0x00010000, //!< Bounding box will be recomputed next time we ask for the BBox
    OBJECT_UPDATE_GEOM          = 0x00020000, //!< Geometry need to be recomputed or updated. This should be done in the C3DBaseObject::Update
    OBJECT_UPDATE_CHANNELS      = 0x00040000, //!< Update autogenerated channels (normals or projected UV for example)
} OBJECT_UPDATE_PROPERTIES;
 
//! @enum OBJECT_COPY_FLAGS
//! Flags used to control the way objects are copied
typedef enum OBJECT_COPY_FLAGS XEnumType(unsigned int)
{
    OBJECT_COPY_DEFAULT = 0x00,
    OBJECT_COPY_CREATE_INSTANCE = 0x10, //!< Create an instance copy of the object that should be affected to a node.
    OBJECT_PREVENT_OBJECT_COPY = 0x100, //!< Used internally. Prevent a node to copy its object (creating an empty node)
    OBJECT_COPY_ALL_CHANNELS = 0x200, //!< If not defined, only CHANNEL_COPY_USEFUL_ONLY are copied (channels than are not auto generated
    //OBJECT_COPY_KEEP_ID = 0x200, // Used internally. Keep the node and object id when copying to a different scene. The returned object/node are not assigned to any scene when set. Otherwise the returned object/node are assigned to the object/node reference scene, unless SetScene is call afterward.
} OBJECT_COPY_FLAGS;
 
//! @class C3DBaseObject
//! @brief This is the base class for any kind of object.
//! @details The kind of C3DBaseObject can be retrieved using GetKindOf, which returns OBJECT_KINDOF. This is a way to cast the C3DBaseObject pointer into to one of its subclasses.
//! Objects can be instantiated, which means referenced several time through the scene. This is why the destructor is protected and you must use Delete instead.\n
//! Cf. @ref OBJECTS to get more details on objects and particularly C3DGeomObject.
class DLL_3DFUNCTION C3DBaseObject : public CXObject, public CInstanciatedObject
{
    DECLARE_SERIAL_XOBJECT(C3DBaseObject);
 
    friend CGeomInfo;
 
public:
    C3DBaseObject();
    virtual bool DeleteFromNode(); // Internal: call from C3DSceneNode to decrease instance count if object has been instanciated. Return true if no instance of the object exists (most of the time this means that the object has been deleted, unless its ref with AddRef somewhere else)
    static C3DBaseObject *Create(OBJECT_KINDOF kindOf); //!< Allocates and creates a new empty object of the given type #OBJECT_KINDOF. Uses xNew internally.
 
    virtual void PostSerialize(CXArchive& ar, bool lastCall); // Called at the end of the scene serialization process
    virtual void Serialize( CXArchive& ar );
 
    //! @name Object instanciation
    //! 
    //! objectGUID allows to get a single ID for a given object. This ID changed each time the object is copied, make any object having a single particular ID, except when object is instanciated.
    //! All the objects instanciation share the same objectGUID.
    //! Important: Instance of an object must be attached to a node, using C3DSceneNode::SetObject. Use AddRef otherwise.
    //! Note: When object are copied between different scene, object instance are kept but a copy of the source is made and it has a different objectGUID
    //!
    //! Instanciation does not support material or UV bindings
    //! Use C3DScene::CreateObjectInstance allow to create a new instance of the given object, or use Copy(OBJECT_COPY_CREATE_INSTANCE), then C3DSceneNode::SetObject
    //!
    //! @{
    BaseObjectID GetObjectID() const; //!< Return the node GUID depending on the scene. If no scene defined, CGuidMgr::UNDEFINED_GUID is returned.
    int GetInstanceCount() const; //!< Return the instance count. If the count then this is a single object that is referenced only one time in the scene
    bool IsInstanciated() const; //!< return true if several instance of the object exists. The C3DSceneNode that reference these instances can be retrieved using C3DScene::GetInstancesByID
 
    //! @}
 
    virtual void SetScene(C3DScene *scene); //!< Associate the object to a scene. a GUID for that object in the scene is assigned.
    C3DScene *GetScene() const; //!< Get the associated object scene
 
    //! @name Checksum
    //!
    //! @brief These methods can be used to know if an object changed between two states.
    //! If the checksum changed then the object too.
    //! @{
    unsigned int GetCustomDataChecksum(unsigned int ignoreCustomID, ...) const; //!< For object which are not geometric object, the checksum could be made on CustomData, and you can ignore some ID might be ignored if they content runtime value that does not reflect a change of the content. The list must be terminated by 0
    virtual unsigned int GetChecksum(unsigned int checksumFlags = CHECKSUM_ALL) const; //!< When not overriden, the checksum is only made on the kind of object. When overidden, only the geometric data is taken into account. CustomData content is ignored, but if it is important a call to GetChecksum(unsigned int, ...) could be done.
 
    //! @}
 
    //! @name Object invalidation
    //! 
    //! @{
    virtual bool NeedUpdate() const;
    virtual bool Update(C3DScene *scene, unsigned int updateMode); //!< Information that have been invalidated are recomputed when calling this method.IsInstanciated
    virtual void Invalidate(unsigned int objectInvalidationFlags, bool set = true); //!< Notify that some information changed (combination of OBJECT_UPDATE_PROPERTIES invalidation flags) and invalidate related information, which will be updated in the Update call. The invalidated information is not destroyed until the next Update call.
    virtual bool InvalidateChannels(unsigned int channelType); //!< Notify that channels that have cache should be recomputed (ie, UVW channel or normal channel for example). This give better control than Invalidate(OBJECT_INV_CHANNELS) which invalidate any channel information. We can specify with this method what need to be invalidated depending on the performed operation. Return true, if a cache has been invalidated
 
    unsigned int GetInvalidateFlags() const; //!< Return the flags that have been invalidated
    bool IsInvalidate(OBJECT_UPDATE_PROPERTIES flag) const; //!< Allow to know if an invalidate flag has been set. Invalidate flag is reset when Update is called.
    longint GetUpdateStamp(OBJECT_UPDATE_PROPERTIES flags) const; //!< Allow to know if the given flag changed between two call
 
    //! @}
 
    //! @name Final object
    //!
    //! @brief Some kind of object might computes a final object, that depends of different internal parameters.
    //! This is the case for C3DPatch for example where the final object depend on the subdivision level.
    //! Most of the time the object and the final object are the same 
    //!
    //! @{
    //! @brief Returns true if this object is the object to be display (GetFinalObject == this) or false if the object to display should be computed from using this internal information (C3DPatch for example)
    virtual bool IsFinalObject() const
    {
        return true;
    }
 
    //! @brief Returns the object itself or any kind of object. For example for a patch it can returns a C3DObject or a C3DPatch if the patch is not subdivided
    virtual C3DBaseObject *GetFinalObject(bool detach = false, bool computeIfNeeded = true) 
    {
        return this;
    };
 
    //! @}
 
    //! @name Object operations
    //!
    //! @{
    virtual bool MatrixTransform(const C4x4Matrix& matrix); //!< Transform the 3D information with the given matrix. The object should not be instanciated or all instance are modified
    C3DBaseObject *Copy(int copyflags = OBJECT_COPY_DEFAULT, C3DObjectCreator *objectCreator = NULL) const;
 
    //! @}
 
    //! @name Kind of object, flags and custom data
    //! 
    //! @{
    void SetFlag(OBJECT_PROPERTIES flag, bool set);
    void SetFlags(unsigned int flags, bool set);
    bool IsFlagSet(OBJECT_PROPERTIES flag) const;
    bool IsOneFlagSet(unsigned int flags) const;
    bool CheckFlags(unsigned int checkflags, bool allSetOrNoneSet) const;
 
    virtual void InheritFlags(const C3DBaseObject& srcObject, int copyflags = OBJECT_COPY_DEFAULT); //!<  This methods only inherits srcObject flags and custom data and optionaly objectGUID / instanceID if srcObject is to be replaced by the object. It does not modify the data structure.
 
    CCustomData& GetCustomData();
    const CCustomData& GetCustomData() const;
 
    //! @anchor cast
    //! @brief Operators (cast operators, return NULL if object is this or if the type is incorrect
    //! It does not perform any geometric or topologic conversions
    operator C3DGeomObject*() const;
    operator C3DGroup*() const; //!< Cf. @ref cast "C3DGeomObject*()"
    operator C3DObject*() const; //!< Cf. @ref cast "C3DGeomObject*()"
    operator C3DCurve*() const; //!< Cf. @ref cast "C3DGeomObject*()"
    operator C3DPatch*() const; //!< Cf. @ref cast "C3DGeomObject*()"
    operator C3DDummy*() const; //!< Cf. @ref cast "C3DGeomObject*()"
    operator C3DLight*() const; //!< Cf. @ref cast "C3DGeomObject*()"
    operator C3DCamera*() const; //!< Cf. @ref cast "C3DGeomObject*()"
 
    bool IsGeomObject() const; //!< return true if the object is an OBJECT_GEOM. Cf. #OBJECT_KINDOF
    OBJECT_KINDOF GetKindOf() const; //!< return #OBJECT_KINDOF, which defines the kind of object. 
    CXString GetTypeString() const; //!< return a string containing the kind of the object ("curve", "camera"...)
 
    //! @}
 
#ifdef _DEBUG
    virtual void Dump(unsigned int flags);
    virtual unsigned int MemoryStats() const;
#endif
 
protected :
    virtual ~C3DBaseObject(); // Use Delete instead
 
    void SetUpdateFlags(unsigned int flag, bool set);
    
    virtual bool InternalCopy(C3DBaseObject *&dstObject, int flags = OBJECT_COPY_DEFAULT, C3DObjectCreator *objectCreator = NULL) const;
 
    OBJECT_KINDOF kindOf;
    unsigned int flags;
    unsigned int updateFlags;
    longint stamps[32];
    CCustomData customData;
    BaseObjectID objectGUID;
    int instanceCount;
 
    C3DScene *scene;
 
private:
    C3DBaseObject& operator=(const C3DBaseObject& refbaseObject) { return *this; };  // Use Copy instead
};
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_3DBASEOBJECT_H__31D6A935_B14E_11D2_A1E5_000000000000__INCLUDED_)