YiSceneManager.h

Go to the documentation of this file.

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

#include "asset/YiAsset.h"
#include "event/YiEvent.h"
#include "event/YiEventHandler.h"
#include "event/YiEventTarget.h"
#include "framework/YiPredef.h"
#include "renderer/YiCameraController.h"
#include "renderer/YiSurface.h"
#include "scenetree/YiSceneNode.h"
#include "signal/YiSignalHandler.h"
#include "thread/YiLocklessCache.h"
#include "utility/YiFocus.h"
#include "utility/YiRtti.h"

#include <glm/fwd.hpp>

class CYIActionEvent;
class CYIColor;
class CYIFocusState;
class CYIMeshFactory;
class CYIOrthographicCameraSceneNode;
class CYIRay;
class CYISceneManagerPriv;
class CYISceneView;
class CYISceneNode;
class CYITimeline;
class CYITimer;
class CYIViewport;
class IYIBufferFactory;
class IYIMaterialFactory;

const uint8_t YI_MAX_POINTER_ID = 10;
const int32_t YI_DELAYED_DOWN_EVENT_DELAY = 115; // 115 ms, same as Android
const int32_t YI_LONG_PRESS_DELAY = 1000; // 1 second
const int32_t YI_LONG_PRESS_MOVE_TOLERANCE = 10; // 10 pixels

class CYISceneManager : public CYIEventHandler, public CYISignalHandler, public CYIScriptableObject
{
    friend class CYIFocusPriv;
    friend class CYISceneManagerPriv;
    friend class CYISceneNode;
    friend class CYISceneNodeUtilityPriv;

public:

    enum LAYER_TYPE
    {
        LAYER_OPAQUE,     
        LAYER_TRANSPARENT 
    };

    enum SCALE_TYPE
    {
        SCALE_FILL,             
        SCALE_FIT,              
        SCALE_STRETCH,          
        SCALE_ACTUAL_SIZE,      
        SCALE_RESPONSIVE_LAYOUT 
    };

    enum V_ALIGN_TYPE
    {
        V_ALIGN_TOP,
        V_ALIGN_CENTER,
        V_ALIGN_BOTTOM
    };

    enum H_ALIGN_TYPE
    {
        H_ALIGN_LEFT,
        H_ALIGN_CENTER,
        H_ALIGN_RIGHT
    };

    enum MISSING_CLASS_HANDLING_MODE
    {
        ABORT,
        SWAP_WITH_SCENE_VIEW
    };

    CYISceneManager();
    virtual ~CYISceneManager();

    std::unique_ptr<CYISceneView> LoadScene(const CYIString &filename,
                                            SCALE_TYPE scaleType = SCALE_STRETCH,
                                            V_ALIGN_TYPE vAlign = V_ALIGN_CENTER,
                                            H_ALIGN_TYPE hAlign = H_ALIGN_CENTER,
                                            MISSING_CLASS_HANDLING_MODE eMissingHandlingMode = ABORT);

    std::unique_ptr<CYISceneView> LoadScene(const CYIString &filename,
                                            const YI_RECT_REL &screenRegion,
                                            SCALE_TYPE scaleType = SCALE_STRETCH,
                                            V_ALIGN_TYPE vAlign = V_ALIGN_CENTER,
                                            H_ALIGN_TYPE hAlign = H_ALIGN_CENTER,
                                            MISSING_CLASS_HANDLING_MODE eMissingHandlingMode = ABORT);

    void UpdateScene(CYISceneView *pRoot);


    void UpdateScene (CYISceneView *pRoot,
                      SCALE_TYPE scaleType,
                      V_ALIGN_TYPE vAlign,
                      H_ALIGN_TYPE hAlign);

    void UpdateScene(CYISceneView *pRoot,
                     const YI_RECT_REL &screenRegion,
                     SCALE_TYPE scaleType = SCALE_STRETCH,
                     V_ALIGN_TYPE vAlign = V_ALIGN_CENTER,
                     H_ALIGN_TYPE hAlign = H_ALIGN_CENTER);

    void UpdateStagedScenes();

    void UpdateUnstagedScenes();

    void UpdateAllScenes();

    void UpdateBackground();

    void OnSurfaceSizeChanged();

    bool GetSceneUpdateProperties(CYISceneView *pRoot, SCALE_TYPE &eScaleType, V_ALIGN_TYPE &eVAlign, H_ALIGN_TYPE &eHAlign) const;

    std::unique_ptr<CYITimeline> ImportTimeline(CYISceneNode *pRootNode, const CYIString &filename);

    bool AddScene(const CYIString &name, std::unique_ptr<CYISceneNode> pSceneNode, int32_t nLayerIndex = 0, LAYER_TYPE eLayerType = LAYER_OPAQUE, const CYIViewport *pCustomViewport = nullptr);

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

    std::unique_ptr<CYISceneNode> RemoveScene(const CYIString &name);

    bool UpdateSceneProperties(const CYIString &name, LAYER_TYPE eLayerType = LAYER_OPAQUE, const CYIViewport *pCustomViewport = nullptr);

    bool GetSceneProperties(const CYIString &name, LAYER_TYPE &eLayerType, CYIViewport &viewport) const;

    uint32_t GetStagedSceneCount() const;

    CYISceneNode *GetStagedScene(uint32_t uIndex) const;

    CYISceneNode *GetStagedScene(const CYIString & name) const;

    std::vector<CYISceneNode *> GetStagedScenes() const;

    uint32_t GetUnstagedSceneCount() const;

    CYISceneNode *GetUnstagedScene(uint32_t uIndex) const;

    CYISceneNode *GetUnstagedScene(const CYIString &name) const;

    std::vector<CYISceneNode *> GetUnstagedScenes() const;

    uint32_t GetSceneCount() const;

    CYISceneNode *GetScene(uint32_t uIndex) const;

    CYISceneNode *GetScene(const CYIString &name) const;

    std::vector<CYISceneNode *> GetScenes() const;

    const CYIString &GetSceneName(CYISceneNode *pScene) const;

    void ShowStagedScenes();

    void HideStagedScenes();

    void ShowScene(const CYIString & name);

    void HideScene(const CYIString & name);

    bool UpdateSceneLayerIndex(const CYIString &name, int32_t nLayerIndex);

    bool GetSceneLayerIndex(const CYIString &name, int32_t &nLayerIndex);

    bool StageScene(const CYIString & name);

    bool StageSceneBefore(const CYIString &name, const CYIString &nameRelative);

    bool StageSceneAfter(const CYIString &name, const CYIString &nameRelative);

    bool StageSceneAtFront(const CYIString &name);

    bool StageSceneAtBack(const CYIString &name);

    bool UnstageScene(const CYIString &name);

    bool IsSceneStaged(const CYIString &name) const;

    void DestroyScenes();

    CYISceneNode  *GetNode(const CYIString & name) const;

    bool MoveBefore(const CYIString &nameToMove, const CYIString &nameRelative);

    bool MoveAfter(const CYIString &nameToMove, const CYIString &nameRelative);

    bool BringToFront(const CYIString &name);

    bool SendToBack(const CYIString &name);

    bool MoveForward(const CYIString &name);

    bool MoveBackward(const CYIString &name);

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

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

    bool Update(bool bForceDirty, bool bForceRender = false);

    bool Layout(CYISceneNode *pNode);

    void Draw() const;

    void SetKeyboardCaptureNode(CYISceneNode *pNode);

    CYISceneNode *GetKeyboardCaptureNode() const;

    void SetPointerCaptureNode(CYISceneNode *pNode, uint8_t uPointerID);

    CYISceneNode *GetPointerCaptureNode(uint8_t uPointerID);

    void SetTrackpadCaptureNode(CYISceneNode *pNode);

    CYISceneNode *GetTrackpadCaptureNode() const;

    void          SetEventCaptureRootNode(CYISceneNode *pNode);

    CYISceneNode *GetEventCaptureRootNode();

    bool AddGlobalEventListener(YI_EVENT_TYPE eEventType, CYIEventHandler *pListener, CYIEventTarget::EVENT_PHASE ePhase = CYIEventTarget::BUBBLE);

    bool RemoveGlobalEventListener(YI_EVENT_TYPE eEventType, CYIEventHandler *pListener, CYIEventTarget::EVENT_PHASE ePhase = CYIEventTarget::BUBBLE);

    void OnSpecialEventTargetDestroyed(CYISceneNode *pNode);

    bool IsReachable(const CYISceneNode *pNode) const;

    CYISceneView *GetViewWithFocus() const;

    CYISceneView *GetViewWithFocus(const CYISceneNode *pRootNode) const;

    bool RequestFocus(const CYISceneView *pViewToFocus, CYIFocus::FOCUS_ROOT_RULE eFocusRootRule = CYIFocus::FOCUS_ROOT_DESCENDANTS_UPDATE_CONTEXT);

    bool MoveFocus(CYIFocus::FOCUS_DIRECTION eDirection, const CYIFocusSearchOptions &options = CYIFocusSearchOptions());

    void ClearFocus();

    bool CanBeFocused(const CYISceneView *pView) const;

    CYICameraController &GetCameraController();

    void QueueTimelineForPlayback(CYITimeline *pTimeline);

    CYISceneNode *GetTargetNodeAtScreenLocation(int32_t nScreenX, int32_t nScreenY) const;

    void SetBackgroundColor(const CYIColor &color);

    const CYIColor &GetBackgroundColor();

    CYISignal<const CYIString &, CYISceneNode *> SceneStaged;

    CYISignal<const CYIString &, CYISceneNode *> SceneUnstaged;

protected:
    bool DispatchEvent(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent, CYISceneNode *pTarget);

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

private:
    struct SCENE_PROPERTIES
    {
        SCALE_TYPE   eScaleType;
        H_ALIGN_TYPE eHorizontalAlignType;
        V_ALIGN_TYPE eVerticalAlignType;
    };

    class LongPressHandler : public CYISignalHandler
    {
    public:
        LongPressHandler(CYISceneManager *pSceneManager, uint8_t nID);
        virtual ~LongPressHandler();
        void OnLongPress();

        uint8_t m_unPointerID;
        std::unique_ptr<CYITimer> m_pTimer;
        std::unique_ptr<CYIActionEvent> m_pActionEvent;
        CYISceneManager *m_pSceneManager;

    private:
        YI_DISALLOW_COPY_AND_ASSIGN(LongPressHandler)
    };

    class DelayedDownHandler : public CYISignalHandler
    {
    public:
        DelayedDownHandler(CYISceneManager *pSceneManager, uint8_t nID);
        virtual ~DelayedDownHandler();
        void OnDelayedDown();

        uint8_t m_uPointerID;
        std::unique_ptr<CYITimer> m_pTimer;
        std::unique_ptr<CYIActionEvent> m_pActionEvent;
        CYISceneManager                    *m_pSceneManager;
        std::shared_ptr<CYISceneNodeProxy> m_target;

    private:
        YI_DISALLOW_COPY_AND_ASSIGN(DelayedDownHandler)
    };

    bool OnMoveEvent(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIActionEvent *pActionEvent, CYISceneNode *pNewMoveTarget);
    bool OnDownEvent(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIActionEvent *pActionEvent, CYISceneNode *pNewMoveTarget);
    bool OnUpEvent(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIActionEvent *pActionEvent, CYISceneNode *pNewMoveTarget);

    void CancelAllActions();
    void CancelLastActionForPointer(uint8_t uPointerID);
    void CancelLastActionUnder(CYISceneNode *pNode);

    bool DispatchEventAs(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIActionEvent *pSrcEvent, CYISceneNode *pTarget, YI_EVENT_TYPE eType);

    void OnPlayTimeline(const std::shared_ptr<CYITimelineProxy> &pProxy);

    void SetSpecialEventTarget(YI_SPECIAL_EVENT_TARGET_TYPE eSpecialType, uint8_t uPointerID, CYISceneNode *pNode);
    CYISceneNode *GetSpecialEventTarget(YI_SPECIAL_EVENT_TARGET_TYPE eSpecialType, uint8_t uPointerID) const;

    void       CreatePickRay(CYIActionEvent *pActionEvent);

    void Shutdown();

    void PutRootNodeBefore(std::unique_ptr<CYISceneNode> pNode, CYISceneNode *pRelativeNode);
    void PutRootNodeAfter(std::unique_ptr<CYISceneNode> pNode, CYISceneNode *pRelativeNode);
    void PutRootNodeAtFront(std::unique_ptr<CYISceneNode> pNode);
    void PutRootNodeAtBack(std::unique_ptr<CYISceneNode> pNode);
    void InsertRootNodeAtIndex(CYISceneNode *pNode, int32_t nLayer);
    void AddChildAtRealIndex(std::unique_ptr<CYISceneNode> pNode);

    std::list<std::pair<CYISceneNode *, int32_t>>::iterator rootListFind(const CYISceneNode *pNode)
    {
        std::list<std::pair<CYISceneNode *, int32_t>>::iterator it = m_RootSceneNodes.begin(), end = m_RootSceneNodes.end();

        for (; it != end; ++it)
        {
            if (it->first == pNode)
            {
                return it;
            }
        }

        return end;
    }

    std::map<CYISceneNode *, SCENE_PROPERTIES>::const_iterator scenePropertyFind(const CYISceneNode *pView) const
    {
        std::map<CYISceneNode *, SCENE_PROPERTIES>::const_iterator it = m_SceneProperties.begin(), end = m_SceneProperties.end();

        for (; it != end; ++it)
        {
            if (it->first == pView)
            {
                return it;
            }
        }

        return end;
    }

    CYISignal<const std::shared_ptr<CYITimelineProxy> &> PlayTimeline;

    std::map<CYIString, CYISceneNode *>  m_StagedRootSceneNodes;

    std::map<CYIString, std::unique_ptr<CYISceneNode>> m_UnstagedRootSceneNodes;

    std::list<std::pair<CYISceneNode *, int32_t>> m_RootSceneNodes;
    std::map<CYISceneNode *, SCENE_PROPERTIES> m_SceneProperties;
    static const SCENE_PROPERTIES s_eDefaultSceneProperties;

    CYICameraController m_CameraController;

    CYISceneNode *m_pLogicalRoot;

    CYISceneNode *m_LastMoveTarget[YI_MAX_POINTER_ID];
    CYISceneNode *m_LastDownTarget[YI_MAX_POINTER_ID];
    CYISceneNode *m_PointerCaptureTarget[YI_MAX_POINTER_ID];
    LongPressHandler *m_LongPressHandlers[YI_MAX_POINTER_ID]; // array of long press handlers, 1 for each pointer.
    DelayedDownHandler *m_DelayedDownHandlers[YI_MAX_POINTER_ID]; // array of delayed down events handlers, 1 for each pointer.
    CYISceneNode *m_pKeyboardCaptureTarget;
    CYISceneNode *m_pCaptureRootNodeTarget;
    CYISceneNode *m_pTrackpadCaptureTarget;

    float m_fCameraScrollAnchorY;

    CYIFocusState *m_pFocusState;

    std::vector<IYIRenderer::Command> m_defaultRenderList;

    bool m_bLayingOut;
    bool m_bShuttingDown;

    std::unique_ptr<CYISceneManagerPriv> m_pPriv;

private:
    YI_DISALLOW_COPY_AND_ASSIGN(CYISceneManager)
};


template <class YI_SCENE_NODE_SUBCLASS> inline YI_SCENE_NODE_SUBCLASS *CYISceneManager::GetNode(const CYIString & name) const
{
    return YiDynamicCast<YI_SCENE_NODE_SUBCLASS>(GetNode(name));
}

#endif // _YI_SCENE_MANAGER_H_