YiSceneNode.h

Go to the documentation of this file.

// © You i Labs Inc. 2000-2017. All rights reserved.
#ifndef _YI_SCENE_NODE_H_
#define _YI_SCENE_NODE_H_

#include "animation/YiAbstractTimeline.h"
#include "animation/YiAnimation.h"
#include "animation/YiVariant.h"
#include "event/YiEventTarget.h"
#include "framework/YiPredef.h"
#include "import/YiPropertiesSource.h"
#include "renderer/YiRenderer.h"
#include "scenetree/YiAABB.h"
#include "signal/YiSignalHandler.h"
#include "utility/YiFocusSearchOptions.h"

#include <glm/mat4x4.hpp>
#include <glm/vec3.hpp>
#include <glm/gtc/quaternion.hpp>

class CYIActionEvent;
class CYIAbstractCameraSceneNode;
class CYIAdjustmentLayerSceneNode;
class CYIEffect;
class CYILayoutConfig;
class CYILayoutState;
class CYIMask;
class CYIMaterial;
class CYIMesh;
class CYIRenderTarget;
class CYISceneManager;
class CYISceneNode;
class CYITimeInterpolator;
class CYITimelineTrack;
class IYIUniformBufferObject;
class CYISceneNodeIteratorPriv;
class CYISceneNodeProxy;

typedef enum
{
    YI_NODE_PROPERTY_UNDEFINED = -1, 
    YI_NODE_PROPERTY_POS_X,          
    YI_NODE_PROPERTY_POS_Y,          
    YI_NODE_PROPERTY_POS_Z,          
    YI_NODE_PROPERTY_SCALE_X,        
    YI_NODE_PROPERTY_SCALE_Y,        
    YI_NODE_PROPERTY_SCALE_Z,        
    YI_NODE_PROPERTY_ROT_X,          
    YI_NODE_PROPERTY_ROT_Y,          
    YI_NODE_PROPERTY_ROT_Z,          
    YI_NODE_PROPERTY_OPACITY,        
    YI_NODE_PROPERTY_SIZE_X,         
    YI_NODE_PROPERTY_SIZE_Y,         
    YI_NODE_PROPERTY_SIZE_Z,         
    YI_NODE_PROPERTY_MAX             
} YI_NODE_PROPERTY_TYPE;

class CYISceneNode : public CYIEventTarget, public CYISignalHandler, public IYIPropertiesSource
{
    friend class CYISceneManager;

public:
    static const float OPACITY_NOT_VISIBLE_EPSILON;

    class Iterator;
    typedef std::reverse_iterator<Iterator> ReverseIterator;

    class Iterator
    {
    public:
        enum ITERATION_MODE
        {
            IMMEDIATE_CHILDREN,
            DEPTH_FIRST,
        };

        friend class CYISceneNode;
        typedef std::bidirectional_iterator_tag iterator_category;
        typedef CYISceneNode *value_type;
        typedef ptrdiff_t difference_type;
        typedef CYISceneNode **pointer;
        typedef CYISceneNode *reference; // This iterator uses the value as the reference, since there is little point in returning a reference to a scene node pointer. The pointer itself suffices.

        Iterator();
        Iterator(const Iterator &other);

        ~Iterator();

        value_type operator*() const;

        Iterator &operator=(const Iterator &other);
        bool operator==(const Iterator &other) const;
        bool operator!=(const Iterator &other) const;

        Iterator &operator++();
        Iterator operator++(int);
        Iterator &operator--();
        Iterator operator--(int);

    private:
        std::unique_ptr<CYISceneNodeIteratorPriv> m_pIteratorPriv;
    };
    
    class PropertyAnimation : public CYIAnimation::Listener
    {
    public:

        PropertyAnimation(CYISceneNode *pNode, YI_NODE_PROPERTY_TYPE ePropType, float fFrom, float fTo, uint32_t nDurMs, CYITimeInterpolator *pTimeInterpolator, bool bDirtyLayout);

        virtual ~PropertyAnimation();

        void Reconfigure(float fFrom, float fTo, uint32_t nDurMs, CYITimeInterpolator *pTimeInterpolator, bool bDirtyLayout);

        std::shared_ptr<CYISceneNodeProxy> m_pNodeProxy; 
        YI_NODE_PROPERTY_TYPE m_eType;                  
        CYIAnimation *m_pAnimation;                     
        float m_fFrom; 
        float m_fTo; 
        bool m_bDirtyLayout;                            
    protected:
        virtual void OnAnimate(CYIAnimation *pAnim, float fDataPosition) override;

        virtual void OnAnimationEnd(CYIAnimation *pAnim) override;

    private:
        YI_DISALLOW_COPY_AND_ASSIGN(PropertyAnimation)
    };

    enum DirtyFlag
    {
        DirtyClean             = 0x0000,

        DirtySceneGraph        = 0x0001,

        DirtyVisibility        = 0x0002,

        DirtyOpacity           = 0x0004,

        DirtyLocalTransform    = 0x0008,

        DirtyWorldTransform    = 0x0010,

        DirtyUniform           = 0x0020,

        DirtyWorldBoundingBox       = 0x0040,

        DirtyMesh              = 0x0080,

        DirtyWorldSurfaceScale = 0x0100,

        DirtyWorldScale        = 0x0200,

        DirtyLocalBoundingBox  = 0x0400,

        DirtyEverything = (DirtySceneGraph | DirtyVisibility | DirtyOpacity | DirtyLocalTransform | DirtyWorldTransform | DirtyUniform | DirtyWorldBoundingBox | DirtyWorldSurfaceScale | DirtyWorldScale | DirtyLocalBoundingBox)
    };

    enum LayoutDirtyFlag
    {
        LayoutClean,
        LayoutChildDirty,
        LayoutDirty
    };

    enum LayoutConfigFetchMode
    {
        LAYOUT_CONFIG_DO_NOT_LAZY_INSTANTIATE = 0,

        LAYOUT_CONFIG_LAZY_INSTANTIATE
    };

    enum MeasureMode
    {
        MEASURE_UNSPECIFIED,
        MEASURE_UP_TO,
        MEASURE_EXACTLY
    };

    enum FETCH_TYPE
    {
        FETCH_OPTIONAL = 0, 
        FETCH_MANDATORY 
    };

    class MeasureSpec
    {
    public:
        MeasureSpec() : eMode(MEASURE_UNSPECIFIED), fSize(0.0f) {}
        MeasureSpec(MeasureMode _eMode, float _fSize) :
            eMode(_eMode),
            fSize(_fSize) {}

        static MeasureSpec CreateExactlySpec(float fSize);
        static MeasureSpec CreateUpToSpec(float fSize);
        static const MeasureSpec &GetUndefinedSpec();
        static const MeasureSpec defaultSpec;

        MeasureMode eMode;
        float fSize;
    };

    CYISceneNode();
    virtual ~CYISceneNode();

    virtual bool Init();

    void             ForceDirty();

    void             ClearDirtyFlag();

    void             SetDirtyFlag(DirtyFlag eDirtyFlag);

    DirtyFlag GetDirtyFlag() const;

    DirtyFlag GetPreviousDirtyFlag() const;

    const CYIString &GetName() const;

    CYIString GetUniqueName() const;

    void            SetSceneManager(CYISceneManager *pSceneManager);

    void             SetName(const CYIString & name);

    int32_t GetID() const;

    void SetID(int32_t nID);

    uint64_t GetUniqueID() const;

    bool AddChild(std::unique_ptr<CYISceneNode> pSceneNode);

    bool AddChild(std::unique_ptr<CYISceneNode>, int32_t nIndex);

    bool InsertChildAfter(CYISceneNode *pRefNode, std::unique_ptr<CYISceneNode> pSceneNode);

    std::unique_ptr<CYISceneNode> RemoveChild(CYISceneNode *pSceneNode);

    bool ReorderChild(uint32_t uFromIndex, uint32_t uToIndex);

    CYISceneNode    *GetParent() const;

    bool ChangeParent(CYISceneNode *pParent);

    CYISceneNode    *GetDrawParent() const;

    bool          IsAncestorOf(const CYISceneNode *pNode) const;

    CYISceneManager *GetSceneManager() const;

    uint32_t GetChildCount() const;

    uint32_t GetChildCountRecursive() const;

    CYISceneNode *GetChild(uint32_t nIndex) const;

    Iterator begin(Iterator::ITERATION_MODE eMode = Iterator::IMMEDIATE_CHILDREN) const;

    Iterator end(Iterator::ITERATION_MODE eMode = Iterator::IMMEDIATE_CHILDREN) const;

    ReverseIterator rbegin(Iterator::ITERATION_MODE eMode = Iterator::IMMEDIATE_CHILDREN) const;

    ReverseIterator rend(Iterator::ITERATION_MODE eMode = Iterator::IMMEDIATE_CHILDREN) const;

    CYISceneNode    *GetChild(const CYIString &sName) const;
    
    uint32_t GetDrawChildCount() const;

    CYISceneNode *GetDrawChild(uint32_t uIndex) const;

    CYISceneNode *GetDrawChildByID(int32_t nID) const;

    template<class YI_SCENE_NODE_SUBCLASS>
    YI_SCENE_NODE_SUBCLASS *GetChild(uint32_t uTargetMatchedNodeCount = 1) const;

    template <class YI_SCENE_NODE_SUBCLASS> std::list<YI_SCENE_NODE_SUBCLASS*> GetChildren() const;

    int32_t GetIndexOfChild(const CYISceneNode *pSceneNode) const;

    void            Show();

    void            Hide();

    void SetVisibility(bool bVisible);

    void SetOpacity(float fOpacity);

    float GetCompositeOpacity() const;

    float GetLocalOpacity() const;

    bool          IsVisible() const;

    bool          IsTrulyVisible() const;

    CYISceneNode      *GetNode(const CYIString & name);

    CYISceneNode      *GetNode(const CYIString & name, const CYIRuntimeTypeInfo &enforceClassType);

    CYISceneNode      *GetNode(const CYIRuntimeTypeInfo &enforceClassType);

    CYISceneNode      *GetNodeAfterTarget(const CYIRuntimeTypeInfo &enforceClassType, CYISceneNode *pStartAfterTarget);

    template <class YI_SCENE_NODE_SUBCLASS> YI_SCENE_NODE_SUBCLASS *GetNode(const CYIString & name);

    CYISceneNode *GetNode(const int32_t nID);

    CYISceneNode *GetNode(const int32_t nID, const CYIRuntimeTypeInfo &enforceClassType);

    template<class YI_SCENE_NODE_SUBCLASS>
    bool FindNode(YI_SCENE_NODE_SUBCLASS *&pNode, const CYIString &nodeName, FETCH_TYPE eType, const CYIString &tag);

    std::list<CYISceneNode*>     GetNodes(const CYIString & name);

    std::list<CYISceneNode *> GetNodes(int32_t nID);

    std::list<CYISceneNode*>     GetNodes(const CYIRuntimeTypeInfo &enforceClassType);

    template<class YI_SCENE_NODE_SUBCLASS>
    const YI_SCENE_NODE_SUBCLASS *GetNode(uint32_t uTargetMatchedNodeCount = 1) const;
    template<class YI_SCENE_NODE_SUBCLASS>
    YI_SCENE_NODE_SUBCLASS *GetNode(uint32_t uTargetMatchedNodeCount = 1);

    void SetMesh(const std::shared_ptr<CYIMesh> &pMesh);

    void SetMaterial(const std::shared_ptr<CYIMaterial> &pMaterial, uint32_t nIndex = 0);

    void AddEffect(const std::shared_ptr<CYIEffect> &pEffect);

    void RemoveEffect(const std::shared_ptr<CYIEffect> &pEffect);

    uint32_t GetEffectCount() const;

    std::shared_ptr<CYIEffect> GetEffect(uint32_t uIndex) const;

    void ConnectEffectsToTimelines(const CYITimelineTrack *pTrack);

    void AddMask(std::unique_ptr<CYIMask> pMask);

    std::unique_ptr<CYIMask> RemoveMask(const CYIMask *pMask);

    uint32_t GetMaskCount() const;

    const CYIMask *GetMask(uint32_t uIndex) const;

    CYIMask *GetMask(uint32_t uIndex);

    const std::shared_ptr<CYIMesh> &GetMesh() const;

    uint32_t GetMaterialCount() const;

    const std::shared_ptr<CYIMaterial> GetMaterial(uint32_t nIndex = 0) const;

    const std::shared_ptr<IYIUniformBufferObject> &GetShaderUniforms() const;

    void SetMeshTransform(const glm::mat4 &rTransform);

    void               DestroyChildren();

    const glm::mat4 &GetLocalTransform() const;

    const glm::mat4 &GetEffectTransform() const;

    const glm::mat4 &GetWorldTransform() const;

    bool          Intersects(const CYISceneNode *pNode) const;

    void SetRenderTarget(const std::shared_ptr<CYIRenderTarget> &pRenderTarget);

    const std::shared_ptr<CYIRenderTarget> GetRenderTarget() const;

    virtual void BuildDrawList(std::vector<IYIRenderer::Command> &drawList, CYIAbstractCameraSceneNode *pCameraToDrawWith = nullptr);

    const CYIAABB &GetWorldAABB() const;

    const CYIAABB &GetLocalAABB() const;

    void SetAnchorPoint(const glm::vec3 &ref);

    void SetAnchorPoint(float fX, float fY, float fZ);

    void SetAnchorPointX(float fX);

    void SetAnchorPointY(float fY);

    void SetAnchorPointZ(float fZ);

    void SetPosition(const glm::vec3 &ref);

    void SetPosition(float fX, float fY, float fZ);

    void SetPositionX(float fX);

    void SetPositionY(float fY);

    void SetPositionZ(float fZ);

    void SetRotation(const glm::vec3 &fEulerDegrees);

    void SetRotation(float fPitchDegrees, float fYawDegrees, float fRollDegrees);

    void SetRotationX(float fPitchDegrees);

    void SetRotationY(float fYawDegrees);

    void SetRotationZ(float fRollDegrees);

    void SetOrientation(float fPitchDegrees, float fYawDegrees, float fRollDegrees);

    void SetOrientation(const glm::quat &orient);

    void SetScale(const glm::vec3 &fScaleFactors);

    void SetScale(float fFactorX, float fFactorY, float fFactorZ);

    void SetScaleX(float fFactor);

    void SetScaleY(float fFactor);

    void SetScaleZ(float fFactor);

    const glm::vec3     &GetPosition() const;

    const glm::vec3     &GetScale() const;

    const glm::vec3     &GetWorldScale() const;

    const glm::vec3     &GetWorldSurfaceScale() const;

    const glm::vec3     &GetRotation() const;

    const glm::quat     &GetOrientation() const;

    const glm::vec3     &GetAnchorPoint() const;

    virtual void SetSize(const glm::vec3 &vSize, bool bDirtyLayout = true);

    const glm::vec3 &GetSize() const;
    
    const glm::vec3 &GetInitialSize() const;

    void SetMeasuredSize(const glm::vec3 &vMeasuredSize);

    const glm::vec3 &GetMeasuredSize() const;

    void SetInternalCustomTimelineValue(uint32_t nTrackID, const CYIVariant &value);

    virtual void SetCustomTimelineValue(uint32_t nTrackID, const CYIVariant &value);

    void SetClippingOn();

    void SetClippingOff();

    bool GetClipping() const;

    void SetClippingBox(const CYIAABB &rWorldBox);

    const CYIAABB &GetClippingBox() const;

    void StartPropertyAnimation(YI_NODE_PROPERTY_TYPE ePropType, float fFrom, float fTo, uint32_t nDurMs, CYITimeInterpolator *pTimeInterpolator = nullptr, bool bDirtyLayout = true);

    void StopPropertyAnimation(YI_NODE_PROPERTY_TYPE ePropType);

    void UpdateLocalSpaceCollision(CYIActionEvent *pActionEvent);

    virtual bool BroadcastEvent(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent);

    void UpdateEventForLocalSpace(CYIActionEvent *pActionEvent, glm::vec3 &rayOrigin, glm::vec3 &rayNonOriginPoint) const;

    bool IsBoundingBoxHit(const CYIRay &rWorldSpaceRay) const;

    bool IsMeshHit(const CYIRay &rWorldSpaceRay) const;

    void DumpTree() const;

    void StartCaptureKeyboardEvents();

    void StopCaptureKeyboardEvents();
    
    void StartCaptureTrackpadEvents();
    
    void StopCaptureTrackpadEvents();

    void StartCapturePointerEvents(uint8_t uPointerID);

    void StopCapturePointerEvents(uint8_t uPointerID);

    bool DrawBehindChildren(CYISceneNode *pSceneNode);

    bool DrawInFrontOfChildren(CYISceneNode *pSceneNode);

    bool DrawBehind(CYISceneNode *pSceneNode);

    bool DrawInFront(CYISceneNode *pSceneNode);

    bool IsFocusRoot() const;

    void SetIsFocusRoot(bool bIsFocusRoot);

    virtual void OnFocusGainedInDescendants();

    virtual void FocusGainedInDescendants();

    virtual void OnFocusLostInDescendants();

    virtual void FocusLostInDescendants();

    virtual void OnFocusChangedInDescendants();

    virtual void FocusChangedInDescendants();


    virtual bool ContainsFocusableDescendant(const CYIFocusSearchOptions &options = CYIFocusSearchOptions()) const;

    void ShowPointerDebugNode(CYIActionEvent *pActionEvent);

    void SetUseLocalTransformAndAlpha(bool bUse);

    static void RegisterAllSceneNodes();

    virtual bool GetProperty(const CYIString &rPropertyName, CYIString *pValue) const override;

    virtual const std::map<CYIString, CYIString> &GetProperties() const override;

    void SetProperty(const CYIString &rPropertyName, const CYIString &rPropertyValue);
    
    const std::shared_ptr<CYISceneNodeProxy> &GetSceneNodeProxy() const;

    void SetLayoutConfig(std::unique_ptr<CYILayoutConfig> pLayoutConfig);

    const CYILayoutConfig *GetLayoutConfig(LayoutConfigFetchMode eFetchMode = LAYOUT_CONFIG_LAZY_INSTANTIATE) const;

    CYILayoutConfig *GetLayoutConfig(LayoutConfigFetchMode eFetchMode = LAYOUT_CONFIG_LAZY_INSTANTIATE);

    void SetLayoutState(std::unique_ptr<CYILayoutState> pLayoutState);

    const CYILayoutState *GetLayoutState() const;

    CYILayoutState *GetLayoutState();

    void RequestLayout();

    LayoutDirtyFlag GetLayoutDirtyFlag() const;

    virtual void SetLayoutDirtyFlag(LayoutDirtyFlag eFlag);

    virtual void Measure(const MeasureSpec &widthSpec, const MeasureSpec &heightSpec, const MeasureSpec &depthSpec);

    virtual void ApplyMeasurements();

    CYIAbstractCameraSceneNode *FindActiveCamera() const;

    template<typename T>
    bool CanCastTo() const;

    CYISignal<CYISceneNode *, YI_NODE_PROPERTY_TYPE> PropertyAnimationComplete;

    CYISignal<> DescendantGainedFocus; 
    CYISignal<> DescendantLostFocus; 
    CYISignal<> DescendantsChangedFocus; 

protected:
    void Update(bool bForceDirty = false);

    virtual void OnUpdateBegin();

    virtual void UpdateBegin();

    virtual void OnUpdateEnd();

    virtual void UpdateEnd();


    virtual void OnDirtyFlagChanged();

    virtual void DirtyFlagChanged();

    virtual void     OnTransformUpdated();

    virtual void TransformUpdated();

    virtual void     OnWorldScaleUpdated();

    virtual void WorldScaleUpdated();

    virtual void     OnWorldSurfaceScaleUpdated();

    virtual void WorldSurfaceScaleUpdated();

    virtual void     OnVisibilityUpdated();

    virtual void VisibilityUpdated();

    virtual void     OnCompositeOpacityUpdated();

    virtual void CompositeOpacityUpdated();

    virtual void     OnWorldBoundingBoxUpdated();

    virtual void WorldBoundingBoxUpdated();

    virtual void OnLocalBoundingBoxUpdated();

    virtual void LocalBoundingBoxUpdated();

    virtual void     OnChildAdded(CYISceneNode *pChild);

    virtual void     ChildAdded(CYISceneNode *pChild);

    virtual void     OnChildRemoved(CYISceneNode *pChild);

    virtual void     ChildRemoved(CYISceneNode *pChild);

    virtual void     OnSizeChanged();

    virtual void     SizeChanged();

    /*
     \details Called to calculate the local transformation matrix. Overrides should call
     the base class implementation for set transformation APIs such as SetPosition()
     to have any effect. Note that get transformation APIs such as GetPosition() do
     not account for custom transformations done in the overrides of this function.

     When data that the custom implementation depends on updates, the subclass is responsible
     for manually triggering local transform recalculation by setting the DirtyLocalTransform flag.
     */
    virtual void     CalculateLocalTransform(glm::mat4 *pTransform) const;

    virtual void     ChildNeedsLayout();

    virtual void     LayoutDirtied();

    virtual void     OnChildVisibilityChanged(CYISceneNode *pChild);

    virtual void     ChildVisibilityChanged(CYISceneNode *pChild);

    virtual bool ProcessEvent(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent) override;

    LayoutDirtyFlag GetCurrentLayoutDirtyFlag() const;

    virtual CYIString GetDumpTreeString() const;

    void DumpTree(int32_t nIndentLevel) const;

    void                        SetShaderUniforms();

    virtual void                SetCustomUniforms();

    template<class T> void SetNodeType();

    virtual CYISceneNode *GetNodeFromChildren(const CYIString &name);

    virtual CYISceneNode *GetNodeFromChildren(const int32_t nID);

    virtual CYISceneNode *GetNodeFromChildren(const CYIRuntimeTypeInfo &enforceClassType);

    CYISceneNode *GetNodeFromChildrenAfterTarget(const CYIRuntimeTypeInfo &enforceClassType, bool *pbTargetReached, CYISceneNode *pStartAfterTarget);

    CYIString                   m_name;
    CYISceneNode               *m_pParent;
    CYISceneNode               *m_pDrawParent;
    CYISceneManager            *m_pSceneManager;

    std::vector<std::unique_ptr<CYISceneNode>> m_children;
    std::vector<CYISceneNode *>             m_drawChildren;
    std::map<CYIString, CYIString>          m_Properties;
    std::vector<std::shared_ptr<CYIMaterial>> m_pMaterials; 
    std::vector<std::unique_ptr<CYIMask>> m_Masks;
    std::vector<std::shared_ptr<CYIEffect>> m_Effects; 
    std::vector<PropertyAnimation*>         m_propertyAnimations;   
    /*
     * These members represent the node's effective alpha value,
     * m_fLocalOpacity - the base opacity for this node, independent of hierarchy
     * m_fCompositeOpacity - the calculated effective opacity for this node, considering its parent chain
     */
    float m_fLocalOpacity; 
    CYIAABB                     m_WSClipBox;                    
    glm::mat4                   m_EffectTransform;
    glm::quat                   m_Orientation;                  
    glm::vec3                   m_Rotate;                       
    glm::vec3                   m_AnchorPoint;                  
    glm::vec3                   m_Position;                     
    glm::vec3                   m_Scale;                        
    glm::vec3                   m_vSize;                        
    glm::vec3                   m_vInitialSize;                 
    glm::vec3                   m_vMeasuredSize;                
    glm::vec3                   m_vlsLastCollision;             
    bool                        m_bClip;                        
    bool                        m_bIsRotated;                   
    bool                        m_bIsOriented;                  
    bool                        m_bLocalVisibility;             
    int32_t m_nID; 
    uint64_t m_uGUID; 
    std::shared_ptr<CYIRenderTarget> m_pRenderTarget; 
    std::shared_ptr<CYIMesh> m_pMesh; 
    mutable std::shared_ptr<IYIUniformBufferObject> m_pShaderUniforms; 
private:
    enum NodeType
    {
        TypeNode            = 0x0001,            
        TypeAbstractCamera  = 0x0002 | TypeNode, 
        TypeAdjustmentLayer = 0x0004 | TypeNode, 
        TypeNPatch          = 0x0008 | TypeNode, 
        TypeSprite          = 0x0010 | TypeNode, 
        TypeImage           = 0x0020 | TypeNode, 
        TypeText            = 0x0040 | TypeNode, 
        TypeView            = 0x0080 | TypeNode, 
        TypeStreamableView  = 0x0100 | TypeView, 
    };

    CYISceneNode *GetNodeFromChildrenLogDuplicates(const CYIString &name);

    void DirtyChildrenRecursive(DirtyFlag eDirtyFlag);      
    void DirtyParentRecursive(DirtyFlag eDirtyFlag);        
    void DirtyLiveChildrenRecursive(DirtyFlag eDirtyFlag);  
    void DirtyLiveParentRecursive(DirtyFlag eDirtyFlag);    
    void             GetNodesFromChildren(const CYIString & name, std::list<CYISceneNode*> & list);
    void GetNodesFromChildren(const int32_t nID, std::list<CYISceneNode *> &list); 
    void             GetNodesFromChildren(const CYIRuntimeTypeInfo &enforceClassType, std::list<CYISceneNode*> & list);
    void             AssignDefaultLayoutConfig() const; 
    void UpdateParent(CYISceneNode *pParent);
    
    void GenerateLocalTransform() const;

    void DrawRemove();

    void ClearLiveDirtyFlag(DirtyFlag eFlag) const;
    void SetLiveDirtyFlag(DirtyFlag eDirtyFlag);
    void SetFrameDirtyFlag(DirtyFlag eDirtyFlag);
    bool IsRotatedInWorldSpace() const;

    virtual void UpdateCompositeOpacity(float *pfCompositeOpacity) const;

    void MakeNextLayoutDirtyFlagCurrent();

    void PushStandardRenderActions(std::vector<IYIRenderer::Command> &drawList, bool bMask, IYIRenderer::Command::CommandType ePushTargetType);
    bool PushEffectRenderActions(std::vector<IYIRenderer::Command> &drawList, bool bMask, const std::shared_ptr<CYIEffect> &pEffect);
    void PopStandardRenderActions(std::vector<IYIRenderer::Command> &drawList, bool bMask);

    mutable glm::mat4 m_localTransform;
    mutable glm::mat4 m_worldTransform;
   
    mutable CYIAABB m_WorldAABB;            
    mutable CYIAABB m_LocalAABB;            
    mutable glm::vec3 m_WorldSurfaceScale;  
    mutable glm::vec3 m_WorldScale;         
    mutable float m_fCompositeOpacity; 
    mutable bool m_bRotatedInWorldSpace;    
    mutable bool m_bCompositeVisibility;    
    bool m_bInitCalled;
    bool m_bDestroying;

    bool m_bIsFocusRoot;
    bool m_bUseLocalTransformAndAlpha;
    std::shared_ptr<CYISceneNodeProxy> m_pSceneNodeProxy;

    CYIAdjustmentLayerSceneNode *m_pLastAdjustmentLayer;

    DirtyFlag m_eFrameDirtyFlag;            
    DirtyFlag m_ePreviousDirtyFlag;         
    mutable DirtyFlag m_eLiveDirtyFlag;     
    mutable DirtyFlag m_eHooksDirtyFlag;    
    LayoutDirtyFlag  m_eCurrentLayoutDirtyFlag;
    LayoutDirtyFlag  m_eNextLayoutDirtyFlag;
    mutable std::unique_ptr<CYILayoutConfig> m_pLayoutConfig;
    std::unique_ptr<CYILayoutState> m_pLayoutState;

    NodeType m_nNodeType;                   
    YI_TYPE_BASES(CYISceneNode, CYIEventTarget)
    YI_DISALLOW_COPY_AND_ASSIGN(CYISceneNode)
};

#include "scenetree/YiSceneNode.inl"

#endif // _YI_SCENE_NODE_H_