3DSceneNode.h

Go to the documentation of this file.

//! @file 3DSceneNode.h
//! @brief C3DSceneNode class definition
//!
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_3DSCENENODE_H__5C85DAE7_BE95_4F8B_B661_B0CF9BE55255__INCLUDED_)
#define AFX_3DSCENENODE_H__5C85DAE7_BE95_4F8B_B661_B0CF9BE55255__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "Tree.h"
#include "3DGeomObject.h"
#include "3DAnimatable.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
#define NODE_REFERENCE_NODE         MAKE_CUSTOM_ID('R', 'F', 'N', 'O') // A binary C3DSceneNode * pointer
#define NODE_LAYER_ID               MAKE_CUSTOM_ID('L', 'Y', 'E', 'R') // Unsigned int
#define NODE_LAYER_BBOX             MAKE_CUSTOM_ID('L', 'Y', 'B', 'X') // 6 floats
#define NODE_JASON_TXT              MAKE_CUSTOM_ID('J', 'S', 'O', 'N') // String: Jason extra data
 
#define NODE_GUID_CLASS MAKE_CUSTOM_ID('N', 'O', 'D', 'E')
 
//! @enum SCENE_NODE_FLAGS
//! Flags defining node properties
typedef enum SCENE_NODE_FLAGS XEnumType(unsigned int)
{
    SCENE_NODE_NONE = 0x00,
    SCENE_NODE_HIDDEN = 0x01, // Node show / hide flag
    SCENE_NODE_IS_SELECTED = 0x02, // Node selection flag
    SCENE_NODE_USER_DEFINED = 0x04, // Node has been created by user. The flag can be used to tag nodes that have been created by user or caller after reading a file
 
    // Caller temporary flags. These flags can be used for specific purposes but it cannot be considered as a safe way to keep an information
    // As different process might use the same flag for different purposes.
    SCENE_NODE_USER_PROPERTIES1 = 0x100000,
    SCENE_NODE_USER_PROPERTIES2 = 0x200000,
    SCENE_NODE_USER_PROPERTIES3 = 0x400000,
    SCENE_NODE_USER_PROPERTIES4 = 0x800000,
} SCENE_NODE_FLAGS;
 
//! @enum SCENE_NODE_UPDATE_PROPERTIES
//! Flags used by C3DSceneNode::Invalidate. Depending on the SCENE_NODE_INV, the method set SCENE_NODE_UPDATE flags that will be processed during C3DSceneNode::Update call
typedef enum SCENE_NODE_UPDATE_PROPERTIES   XEnumType(unsigned int)
{
    SCENE_NODE_UPDATE_NONE =    0x0000000,
 
    SCENE_NODE_INV_FLAGS            = 0xFFFF,
    SCENE_NODE_INV_ALL              = SCENE_NODE_INV_FLAGS,
    SCENE_NODE_INV_DISPLAY          = 0x0001, // Node should be redrawn (ie, the matrix, an attribute changed, or name changed). If the attached object change, it must be invalidated too
    SCENE_NODE_INV_DATA             = 0x000, // Node custom data changed
 
    SCENE_NODE_UPDATE_ALL =     0xFFFF0000,
} SCENE_NODE_UPDATE_PROPERTIES;
 
//! @class C3DSceneNode
//! @brief A node matches one element that is part of the C3DScene graph. It references a C3DBaseObject and has some properties such matrix name, transformation, user custom data...
//! @details Several nodes might reference the same object, which is called instantiation process.
//! Nodes are organized hierarchically in the scene.\n
//! Cf. @ref NODES to get more details on node usage.
//! @note C3DSceneNode is not instantiable.
class DLL_3DFUNCTION C3DSceneNode : protected CTreeNode, public C3DKeyframable
{
    friend C3DScene;
 
    DECLARE_SERIAL_XOBJECT(C3DSceneNode)
 
public:
    C3DSceneNode(C3DBaseObject *nodeObject = NULL); // Create a node with an optional object attached to the node
    virtual ~C3DSceneNode(); // Use Delete instead
 
    static C3DSceneNode *Create(); // Allocates and creates an empty node.  Same as xNew(C3DSceneNode).
    virtual bool Delete(); // Delete a node when it has not been attached to a scene
 
    virtual void PostSerialize(CXArchive& ar, bool lastCall); // Called at the end of the scene serialization process, both when loading and saving
    virtual void Serialize(CXArchive& ar);
 
    SceneNodeID32 GetNodeID32() const; // Return a 32 bits version of the GUID.
    SceneNodeID GetNodeID() const; // Return the node GUID depending on the scene. If no scene defined, CGuidMgr::UNDEFINED_GUID is returned.
    BaseObjectID GetObjectID() const; // Retrieve object ID
    SceneNodeID SetNodeID(SceneNodeID nodeid); // Replace the node ID by a new one. If nodeid GUID already exists, then the provided value might be modified.
 
    OBJECT_KINDOF GetObjectKindOf() const
    {
        if (object)
            return object->GetKindOf();
 
        return OBJECT_UNKNOWN;
    }
 
    void SetScene(C3DScene *scene); // Define the scene to which the node belong to. Set the attached object scene to. A node cannot belong to several scene, but it could be not rely to any scene
    void SetObject(C3DBaseObject *pObj, bool deletePrevious = true);
    C3DScene* GetScene() { return scene; }
    C3DBaseObject *GetBaseObject(int time = 0) const;
    C3DGeomObject *GetGeomObject(int time = 0) const;
    bool IsGeomObject() const;
    C3DBaseObject *GetFinalObject(int time = 0, bool computeIfNeeded = true) const;
    CCustomData& GetCustomData() { return customData; }
    const CCustomData& GetCustomData() const { return customData; }
 
    void SetFlag(SCENE_NODE_FLAGS flag, bool set);
    void SetFlags(unsigned int flags, bool set);
    bool IsFlagSet(unsigned int flag) const;
    bool IsOneFlagSet(unsigned int flags) const;
    bool CheckFlags(unsigned int checkflags, bool allSetOrNoneSet) const;
 
    void Update(unsigned int updateMode);
    void Invalidate(unsigned int sceneNodeInvFlags, bool set = true); // A combination of invalidation flags in SCENE_NODE_UPDATE_PROPERTIES. 
    void InvalidateNodeAndObject(unsigned int sceneNodeInvFlags, unsigned int objectInvalidationFlags); // Invalidate both node and associated object (SCENE_NODE_UPDATE_PROPERTIES and OBJECT_UPDATE_PROPERTIES combinations)
    bool IsInvalidate(SCENE_NODE_UPDATE_PROPERTIES flag) const;
 
    // Animation
    using C3DKeyframable::GetTimeRange;
 
    // Matrix methods
    // GetNodeLocalTM is useful for exporting (retrieve a matrix without pivot)
    // GetObjectLocalTM / GetNodeTM is useful for displaying an object. It handles all the transformation information readed from a file (matrix, scale, rotate, pivot...)
    void GetNodeLocalTM(int time, C4x4Matrix& matrix) const; // A node local matrix (without pivot consideration), useful for exporting to parser which does not handle pivot
    void SetObjectLocalTM(int time, const C4x4Matrix& localMatrix, bool allowTrsDecomposition = true); // Set the object matrix. If allowTrsDecomposition, and the matrix can be decompose in translation / rotation / scale then KEYFRAME_TRANS, KEYFRAME_ROT, KEYFRAME_SCALE are updated and previous KEYFRAME_MATRIX transform is removed. If allowTrsDecomposition = false, then KEYFRAME_MATRIX is updated and KEYFRAME_TRANS, KEYFRAME_ROT, KEYFRAME_SCALE are removed. If time = C3DKeyframable::INVALID_TIME, then matrix is ignored and all transformation are removed
    void GetObjectLocalTM(int time, C4x4Matrix& matrix) const; // The object local transformation matrix
    void GetNodeTM(int time, C4x4Matrix& matrix, bool includeRootOrientation = true, bool excludePivot = false) const; // The node transformation matrix (taking the pivot into account)
    void CenterPivotOnCG(const C3DVector& bboxOffset = C3DVector(0.5, 0.5, 0.5), const C3DVector& additionalOffset = C3DVector(0.0, 0.0, 0.0)); // Center the object at the world origin and modify the transformation matrix accordingly in order to keep the object at the same position. This result at making the pivot being centered on the CG
    bool SwapPoints(unsigned int swapMode); // Swap node object points
    bool SwapTransformations(unsigned int swapMode); // Swap node transformation
    bool ConvertToGlobalCoordinates(int time); // Convert to matrix using the local node matrix (as node keeps its parent). Return true if node changed (beware internal object might changed, must call C3DSceneNode::GetBaseObject after operation), false if matrix is identity or node unchanged by the method. Use C3DScene::ConvertToGlobalCoordinates for removing transformation to a node branch
    bool ConvertToGlobalCoordinates(const C4x4Matrix& matrix); // Convert to global coordinates using an alternative matrix. This remove the object instanciation, as it turns the coord to global only for the specified node
 
    // Instanciation
    bool DeleteObjectInstanciation(); // Remove instanciation for the node and replace it by a real copy. Return false if no instanciation exists for the node, true if the instance has been replaced by a copy
    bool IsObjectIntanciated(bool checkChilds = false) const; // Return true if the node's object is instanciated. If checkChilds = true, returns true if the whole child branch is made of instance (any childs of the node contains an object instance (excluding the node itself))
 
    // Geometry information
    bool GetBoundingBox(int time, C3DBBox& bbox, unsigned int bboxflags, unsigned int extraNodeOrPtFaceFlags = 0, unsigned int extraKindOfObject = OBJECT_UNKNOWN); // Note: BBOX_NODE_TRANSFORM set in bboxflags then all points are transformed with matrix node. Otherwise the node transform is only applied to bounding box. If no node transform is required, BBOX_DONT_APPLY_NODE_TRANSFORM must be used.
    bool GetBoundingBox(int time, C3DPoint& point1, C3DPoint& point2, unsigned int bboxflags, unsigned int extraNodeOrPtFaceFlags = 0, unsigned int extraKindOfObject = OBJECT_UNKNOWN); // Note: BBOX_NODE_TRANSFORM set in bboxflags then all points are transformed with matrix node. Otherwise the node transform is only applied to bounding box. If no node transform is required, BBOX_DONT_APPLY_NODE_TRANSFORM must be used.
    bool GetCG(int time, C3DPoint& CG);
 
    // name
    void SetName(const CXString& name);
    CXString GetName() const;
 
    void Inherit(const C3DSceneNode *from, int flags = OBJECT_COPY_DEFAULT); // Inherit the node properties (flag, customdata, keyframe). if OBJECT_COPY_KEEP_ID is defined, the node inherit from nodeID. Caller is responsible to attach the node to a scene using C3DScene::AddNode or to call SetScene. The node attached object is not modified by inherit
    C3DSceneNode *Copy(int copyFlags = OBJECT_COPY_DEFAULT, C3DObjectCreator *objectCreator = NULL) const;
    C3DSceneNode *CopyBranch(C3DSceneNode *parent = NULL, int copyFlags = OBJECT_COPY_DEFAULT, C3DObjectCreator *objectCreator = NULL) const; // Copy a branch 
 
    // Specific purposes 
    CTreeNode *GetTreeNode() { return this; } // CTreeNode base class has protected access, so use this with precaution
 
#ifdef _DEBUG
    virtual bool Dump(unsigned int flags) const;
#endif
 
protected:
    C3DScene *scene;
    C3DBaseObject *object;
    CCustomData customData;
 
    SceneNodeID nodeGUID;
 
    int nodeFlags;
    int updateFlags;
 
    CXString name;
 
    mutable struct CacheData
    {
        typedef enum ValidData XEnumType(unsigned int)
        {
            VALID_NONE,
            VALID_NODE_TM,
            VALID_LOCAL_TM,
        } ValidData;
 
        unsigned int validData;
        int time;
        C4x4Matrix nodeTm, localTm;
 
        bool IsValid(unsigned int time, ValidData flag);
    } cacheData;
 
    void InitNode();
    void SetInvalidateFlag(unsigned int flag, bool set);
    virtual void OnParentingChanged() const; // Notify that a change occurs in parenting
    virtual void OnKeyframesChanged(longuint classID) const; // Notify that something changed in the keyframes. classID == KEYFRAME_NULLID, if all kind of keyframe changed
 
    bool InternalGetBoundingBox(int time, C3DPoint& point1, C3DPoint& point2, unsigned int bboxflags, unsigned int elmtflags, bool set) const;
    bool InternalGetCG(int time, C3DPoint& CG) const;
 
    // Inherited from CTree, low level access
    virtual CXString GetDisplayName() const;
 
private:
    virtual C3DSceneNode& operator=(const C3DSceneNode& refnode) { return *this; }; // Use copy instead, or inherit to get node flags and matrices
};
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_3DSCENENODE_H__5C85DAE7_BE95_4F8B_B661_B0CF9BE55255__INCLUDED_)