You.i Engine
YiSceneManager.h
Go to the documentation of this file.
1 // © You i Labs Inc. All rights reserved.
2 #ifndef _YI_SCENE_MANAGER_H_
3 #define _YI_SCENE_MANAGER_H_
4 
5 #include "event/YiEvent.h"
6 #include "event/YiEventHandler.h"
7 #include "event/YiEventTarget.h"
8 #include "focus/YiFocus.h"
9 #include "graphics/YiRectangle.h"
10 #include "signal/YiSignalHandler.h"
11 #include "utility/YiTimer.h"
12 
13 #include <glm/fwd.hpp>
14 #include <glm/gtc/epsilon.hpp>
15 
16 #include <array>
17 #include <list>
18 #include <map>
19 
21 class CYIActionEvent;
22 class CYIColor;
23 class CYIFocusEngine;
25 class CYIRay;
26 class CYISceneManager;
27 class CYISceneManagerPriv;
28 class CYISceneNode;
29 class CYISceneNodeProxy;
30 class CYISceneView;
31 class CYITimeline;
32 class CYITimelineProxy;
33 class CYITransformSystem;
34 class CYIViewport;
35 class CYIViewTemplate;
36 class IYIEventMonitor;
37 class IYIPropertyChangeMonitor;
38 
44 const uint8_t YI_MAX_POINTER_ID = 10;
45 const int32_t YI_DELAYED_DOWN_EVENT_DELAY = 115; // 115 ms, same as Android
46 const int32_t YI_LONG_PRESS_DELAY = 1000; // 1 second
47 const int32_t YI_LONG_PRESS_MOVE_TOLERANCE = 10; // 10 pixels
48 
49 using CYICameraFactory = std::function<std::unique_ptr<CYIAbstractCameraSceneNode>(
50  CYISceneManager *pSceneManager,
51  const std::shared_ptr<CYIViewTemplate> &pViewTemplate,
52  CYISceneView *pRootComposition)>;
53 
83 {
84  friend class CYIFocusPriv;
85  friend class CYISceneManagerPriv;
87 
88 public:
96  enum class LayerType
97  {
98  Opaque,
100  };
101 
107  enum class ScaleType
108  {
109  Fill,
110  Fit,
111  Stretch,
112  ActualSize,
113  ResponsiveLayout
114  };
115 
122  {
123  Top,
124  Center,
125  Bottom
126  };
127 
134  {
135  Left,
136  Center,
137  Right
138  };
139 
146  {
147  Abort,
148  SwapWithSceneView
149  };
150 
151  CYISceneManager(std::unique_ptr<CYIFocusEngine> pFocusEngine);
152  virtual ~CYISceneManager();
153 
161  std::unique_ptr<CYISceneView> CreateScene(const YI_RECT_REL &worldRegionOfInterest,
162  ScaleType scaleType = ScaleType::Stretch,
165 
174  std::unique_ptr<CYISceneView> LoadScene(const CYIString &filename,
175  ScaleType scaleType = ScaleType::Stretch,
179  CYICameraFactory cameraFactory = nullptr);
180 
188  std::unique_ptr<CYISceneView> LoadScene(const CYIString &filename,
189  const YI_RECT_REL &screenRegion,
190  ScaleType scaleType = ScaleType::Stretch,
194  CYICameraFactory cameraFactory = nullptr);
195 
202  void UpdateScene(CYISceneView *pRoot);
203 
210  void UpdateScene(CYISceneView *pRoot,
211  ScaleType scaleType,
212  VerticalAlignmentType vAlign,
213  HorizontalAlignmentType hAlign);
214 
221  void UpdateScene(CYISceneView *pRoot,
222  const YI_RECT_REL &screenRegion,
223  ScaleType scaleType = ScaleType::Stretch,
226 
233  void UpdateStagedScenes();
234 
241  void UpdateUnstagedScenes();
242 
249  void UpdateAllScenes();
250 
256  void UpdateBackground();
257 
264  void OnSurfaceSizeChanged();
265 
274  bool GetSceneUpdateProperties(CYISceneView *pRoot, ScaleType &scaleType, VerticalAlignmentType &vAlign, HorizontalAlignmentType &hAlign) const;
275 
293  bool AddScene(const CYIString &name, std::unique_ptr<CYISceneNode> pSceneNode, size_t layerIndex = 0, LayerType layerType = LayerType::Opaque, const CYIViewport *pCustomViewport = nullptr);
294 
300  std::unique_ptr<CYISceneNode> RemoveScene(CYISceneNode *pSceneNode);
301 
305  std::unique_ptr<CYISceneNode> RemoveScene(const CYIString &name);
306 
316  bool UpdateSceneProperties(const CYIString &name, LayerType layerType = LayerType::Opaque, const CYIViewport *pCustomViewport = nullptr);
317 
325  bool GetSceneProperties(const CYIString &name, LayerType &layerType, CYIViewport &viewport) const;
326 
330  size_t GetStagedSceneCount() const;
331 
339  CYISceneNode *GetStagedScene(size_t index) const;
340 
346  CYISceneNode *GetStagedScene(const CYIString &name) const;
347 
355  std::vector<CYISceneNode *> GetStagedScenes() const;
356 
360  size_t GetUnstagedSceneCount() const;
361 
369  CYISceneNode *GetUnstagedScene(size_t index) const;
370 
376  CYISceneNode *GetUnstagedScene(const CYIString &name) const;
377 
385  std::vector<CYISceneNode *> GetUnstagedScenes() const;
386 
390  size_t GetSceneCount() const;
391 
399  CYISceneNode *GetScene(size_t index) const;
400 
406  CYISceneNode *GetScene(const CYIString &name) const;
407 
415  std::vector<CYISceneNode *> GetScenes() const;
416 
420  const CYIString &GetSceneName(CYISceneNode *pScene) const;
421 
425  void ShowScene(const CYIString &name);
426 
430  void HideScene(const CYIString &name);
431 
435  bool GetSceneLayerIndex(const CYIString &name, size_t &layerIndex);
436 
444  bool SetSceneLayerIndex(const CYIString &name, size_t layerIndex);
445 
451  bool StageScene(const CYIString &name);
452 
458  bool UnstageScene(const CYIString &name);
459 
463  bool IsSceneStaged(const CYIString &name) const;
464 
468  void DestroyScenes();
469 
475  bool Update(bool forceDirty, bool forceRender = false);
476 
484  bool Layout(CYISceneNode *pNode);
485 
492 
497 
505  void SetPointerCaptureNode(CYISceneNode *pNode, uint8_t pointerID);
506 
510  CYISceneNode *GetPointerCaptureNode(uint8_t pointerID);
511 
518 
523 
530 
535 
542 
549 
553  bool IsReachable(const CYISceneNode *pNode) const;
554 
559 
564  CYISceneView *GetViewWithFocus(const CYISceneNode *pRootNode) const;
565 
578 
586  bool MoveFocus(CYIFocus::Direction direction, const CYIFocusSearchOptions &options = CYIFocusSearchOptions());
587 
591  void ClearFocus();
592 
602  bool CanBeFocused(const CYISceneView *pView) const;
603 
608  void QueueTimelineForPlayback(CYITimeline *pTimeline);
609 
613  CYISceneNode *GetTargetNodeAtScreenLocation(int32_t screenX, int32_t screenY) const;
614 
623  void SetBackgroundColor(const CYIColor &color);
624 
630  const CYIColor &GetBackgroundColor();
631 
635  void SetDrawSkipEnabled(bool enabled);
636 
642  bool IsDrawSkipEnabled() const;
643 
644  /*!*
645  \details Causes the scene to be redrawn during the next frame. This can be used to force a redraw when GPU assets are modified directly.
646  */
647  void RequestRerender();
648 
653 
658 
664  void SetPropertyChangeMonitor(IYIPropertyChangeMonitor *pMonitor);
665 
666  IYIPropertyChangeMonitor *GetPropertyChangeMonitor();
667 
673  void SetEventMonitor(IYIEventMonitor *pMonitor);
674 
675  IYIEventMonitor *GetEventMonitor();
676 
677 protected:
682  bool DispatchEvent(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent, CYISceneNode *pTarget);
683 
687  virtual bool HandleEvent(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent) override;
688 
689 private:
690  enum class EventTargetType : uint8_t
691  {
692  PointerCapture,
693  KeyboardCapture,
694  TrackpadCapture,
695  Root
696  };
697 
698  struct SCENE_PROPERTIES
699  {
700  SCENE_PROPERTIES();
701  SCENE_PROPERTIES(ScaleType scale, HorizontalAlignmentType hAlign, VerticalAlignmentType vAlign);
702 
703  ScaleType scaleType;
704  HorizontalAlignmentType horizontalAlignType;
705  VerticalAlignmentType verticalAlignType;
706  };
707 
708  class EventDispatcher
709  {
710  public:
711  virtual void HandleEventBeforeDispatch(const std::shared_ptr<CYIEventDispatcher> &, CYIEvent *) {}
712  virtual void HandleEventAfterDispatch(const std::shared_ptr<CYIEventDispatcher> &, CYIEvent *) {}
713  virtual void CancelEventsInSubtree(CYISceneNode *) {}
714  virtual void CancelAllEvents() {}
715 
716  protected:
717  EventDispatcher() = default;
718  };
719 
720  class DelayedDownDispatcher : public EventDispatcher, public CYISignalHandler
721  {
722  public:
723  DelayedDownDispatcher(CYISceneManager &sceneManager);
724 
725  void HandleEventBeforeDispatch(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent) override;
726 
727  void CancelAllEvents() override;
728  void CancelEventsInSubtree(CYISceneNode *pRoot) override;
729 
730  private:
731  void OnDelayedDown(uint8_t pointerId);
732 
733  CYISceneManager &m_sceneManager;
734  std::array<std::shared_ptr<CYISceneNodeProxy>, YI_MAX_POINTER_ID> m_targets;
735  std::array<std::unique_ptr<CYIActionEvent>, YI_MAX_POINTER_ID> m_actionEvents;
736  std::array<CYITimer, YI_MAX_POINTER_ID> m_timers;
737  };
738 
739  class SynthesizedActionEventDispatcher : public EventDispatcher
740  {
741  public:
742  SynthesizedActionEventDispatcher(CYISceneManager &sceneManager);
743 
744  void HandleEventBeforeDispatch(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent) override;
745  void HandleEventAfterDispatch(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent) override;
746 
747  void CancelAllEvents() override;
748  void CancelEventsInSubtree(CYISceneNode *pRoot) override;
749 
750  private:
751  void HandleChangeOfCursorFocus(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIActionEvent *pActionEvent, CYISceneNode *pOldTarget, CYISceneNode *pNewTarget);
752 
753  CYISceneManager &m_sceneManager;
754  std::array<std::shared_ptr<CYISceneNodeProxy>, YI_MAX_POINTER_ID> m_lastMoveTargets;
755  std::array<std::shared_ptr<CYISceneNodeProxy>, YI_MAX_POINTER_ID> m_clickTargets;
756  };
757 
758  class FocusDispatcher : public EventDispatcher
759  {
760  public:
761  FocusDispatcher(CYIFocusEngine &focusEngine);
762 
763  void HandleEventAfterDispatch(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent) override;
764 
765  private:
766  CYIFocusEngine &m_focusEngine;
767  };
768 
769  class LongPressDispatcher : public EventDispatcher, public CYISignalHandler
770  {
771  public:
772  LongPressDispatcher(CYISceneManager &sceneManager);
773 
774  void HandleEventBeforeDispatch(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent) override;
775 
776  void Cancel();
777  void CancelBelongingTo(CYISceneNode *pRoot);
778 
779  private:
780  void OnLongPress(uint8_t pointerId);
781 
782  CYISceneManager &m_sceneManager;
783  std::array<std::shared_ptr<CYISceneNodeProxy>, YI_MAX_POINTER_ID> m_targets;
784  std::array<std::unique_ptr<CYIActionEvent>, YI_MAX_POINTER_ID> m_actionEvents;
785  std::array<CYITimer, YI_MAX_POINTER_ID> m_timers;
786  };
787 
788  class BackButtonDispatcher : public EventDispatcher
789  {
790  public:
791  BackButtonDispatcher();
792 
793  void HandleEventAfterDispatch(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent) override;
794  };
795 
799  void CancelAllActions();
800 
807  void CancelLastActionUnder(CYISceneNode *pNode);
808 
812  void OnPlayTimeline(const std::shared_ptr<CYITimelineProxy> &pProxy);
813 
814  CYIRay CreatePickRay(int32_t x, int32_t y);
815 
816  void Shutdown();
817 
818  void InsertRootNodeAtIndex(CYISceneNode *pNode, size_t layer);
819  void AddChildAtRealIndex(std::unique_ptr<CYISceneNode> pNode);
820 
821  std::list<std::pair<CYISceneNode *, size_t>>::iterator rootListFind(const CYISceneNode *pNode)
822  {
823  std::list<std::pair<CYISceneNode *, size_t>>::iterator it = m_RootSceneNodes.begin(), end = m_RootSceneNodes.end();
824 
825  for (; it != end; ++it)
826  {
827  if (it->first == pNode)
828  {
829  return it;
830  }
831  }
832 
833  return end;
834  }
835 
839  CYITransformSystem *GetTransformSystem();
840 
844  const CYITransformSystem *GetTransformSystem() const;
845 
847 
851  std::map<CYIString, CYISceneNode *> m_StagedRootSceneNodes;
852 
856  std::map<CYIString, std::unique_ptr<CYISceneNode>> m_UnstagedRootSceneNodes;
857 
858  std::list<std::pair<CYISceneNode *, size_t>> m_RootSceneNodes;
859  std::map<CYISceneNode *, SCENE_PROPERTIES> m_SceneProperties;
860  static const SCENE_PROPERTIES s_defaultSceneProperties;
861 
862  std::unique_ptr<CYISceneNode> m_pLogicalRoot;
863 
864  void SetSpecialEventTarget(EventTargetType specialType, uint8_t pointerID, CYISceneNode *pNode);
865  CYISceneNode *GetSpecialEventTarget(EventTargetType specialType, uint8_t pointerID) const;
866 
867  std::shared_ptr<CYISceneNodeProxy> &GetTargetProxyReference(EventTargetType specialType, uint8_t pointerID);
868  const std::shared_ptr<CYISceneNodeProxy> &GetTargetProxyReference(EventTargetType specialType, uint8_t pointerID) const;
869 
870  DelayedDownDispatcher m_delayedDownDispatcher;
871  LongPressDispatcher m_longPressDispatcher;
872  SynthesizedActionEventDispatcher m_synthesizedActionEventDispatcher;
873  FocusDispatcher m_focusDispatcher;
874  BackButtonDispatcher m_backButtonDispatcher;
875  std::array<EventDispatcher *, 5> m_eventDispatchers;
876 
877  std::shared_ptr<CYISceneNodeProxy> m_pKeyboardCaptureTarget;
878  std::shared_ptr<CYISceneNodeProxy> m_pCaptureRootNodeTarget;
879  std::shared_ptr<CYISceneNodeProxy> m_pTrackpadCaptureTarget;
880  std::array<std::shared_ptr<CYISceneNodeProxy>, YI_MAX_POINTER_ID> m_PointerCaptureTarget;
881 
882  float m_cameraScrollAnchorY;
883 
884  bool m_layingOut;
885  bool m_shuttingDown;
886  bool m_drawSkip;
887 
888  std::unique_ptr<CYIFocusEngine> m_pFocusEngine;
889 
890  std::unique_ptr<CYISceneManagerPriv> m_pPriv;
891 
892  IYIPropertyChangeMonitor *m_pPropertyChangeMonitor;
893  IYIEventMonitor *m_pEventMonitor;
894 
895  std::unique_ptr<CYITransformSystem> m_pTransformSystem;
896 
898 };
899 
902 #endif // _YI_SCENE_MANAGER_H_
void SetKeyboardCaptureNode(CYISceneNode *pNode)
Phase
Definition: YiEventTarget.h:34
std::vector< CYISceneNode * > GetUnstagedScenes() const
friend class CYIFocusPriv
Definition: YiSceneManager.h:84
void SetEventMonitor(IYIEventMonitor *pMonitor)
void SetEventCaptureRootNode(CYISceneNode *pNode)
#define YI_DISALLOW_COPY_AND_ASSIGN(TypeName)
Delete the copy constructor and assignment operator (and consequently the move constructor as well) ...
Definition: YiPredef.h:69
void RequestRerender()
LayerType
Specifies layering rules on a scene. Transparent scenes may be drawn over other scenes.
Definition: YiSceneManager.h:96
const CYIString & GetSceneName(CYISceneNode *pScene) const
A class containing focus search options.
Definition: YiFocusSearchOptions.h:21
const int32_t YI_LONG_PRESS_DELAY
Definition: YiSceneManager.h:46
bool RequestFocus(const CYISceneView *pViewToFocus, CYIFocus::FocusRootRule focusRootRule=CYIFocus::FocusRootRule::DescendantsUpdateContext)
bool AddGlobalEventListener(CYIEvent::Type eventType, CYIEventHandler *pListener, CYIEventTarget::Phase phase=CYIEventTarget::Phase::Bubble)
A class used to proxy access to a CYIAbstractTimeline.
Definition: YiTimelineProxy.h:19
bool IsReachable(const CYISceneNode *pNode) const
Allows registering of event filters which can be used to perform processing on an event before and af...
Definition: YiEventHandler.h:25
Scene trees composed of CYISceneNode objects are registered with the scene manager in order for them ...
Definition: YiSceneManager.h:82
Definition: YiRectangle.h:38
const uint8_t YI_MAX_POINTER_ID
Definition: YiSceneManager.h:44
A timeline which sources its data from a backing store.
Definition: YiTimeline.h:53
bool SetSceneLayerIndex(const CYIString &name, size_t layerIndex)
Base class for events.
Definition: YiEvent.h:28
The base class for all view types. Views are containers of renderable elements that often define inte...
Definition: YiSceneView.h:46
VerticalAlignmentType
Vertical alignment.
Definition: YiSceneManager.h:121
CYISceneNode * GetScene(size_t index) const
Container class for Unicode strings. Conceptually, a CYIString object is a sequence of Unicode charac...
Definition: YiString.h:32
bool UnstageScene(const CYIString &name)
Definition: YiOrthographicCameraSceneNode.h:27
bool GetSceneProperties(const CYIString &name, LayerType &layerType, CYIViewport &viewport) const
Provides a base for the definition of camera objects.
Definition: YiAbstractCameraSceneNode.h:31
bool StageScene(const CYIString &name)
void OnSurfaceSizeChanged()
Direction
Definition: YiFocus.h:44
virtual ~CYISceneManager()
ScaleType
Scaling rules define how the scene adapts to having different dimensions.
Definition: YiSceneManager.h:107
CYISignal< const CYIString &, CYISceneNode * > SceneUnstaged
Definition: YiSceneManager.h:657
void DestroyScenes()
A class used to proxy access to a CYISceneNode.
Definition: YiSceneNodeProxy.h:26
bool GetSceneUpdateProperties(CYISceneView *pRoot, ScaleType &scaleType, VerticalAlignmentType &vAlign, HorizontalAlignmentType &hAlign) const
size_t GetSceneCount() const
void SetTrackpadCaptureNode(CYISceneNode *pNode)
CYISceneNode * GetTrackpadCaptureNode() const
Definition: YiViewport.h:12
const int32_t YI_DELAYED_DOWN_EVENT_DELAY
Definition: YiSceneManager.h:45
CYISceneManager(std::unique_ptr< CYIFocusEngine > pFocusEngine)
CYISceneNode * GetStagedScene(size_t index) const
CYISceneNode * GetKeyboardCaptureNode() const
bool AddScene(const CYIString &name, std::unique_ptr< CYISceneNode > pSceneNode, size_t layerIndex=0, LayerType layerType=LayerType::Opaque, const CYIViewport *pCustomViewport=nullptr)
Encapsulates the origin and direction points of a ray.
Definition: YiRay.h:32
The transform system maintains a component pool of CYITransformComponent data.
Definition: YiTransformSystem.h:21
CYISceneNode * GetTargetNodeAtScreenLocation(int32_t screenX, int32_t screenY) const
CYISceneView * GetViewWithFocus() const
std::unique_ptr< CYISceneView > CreateScene(const YI_RECT_REL &worldRegionOfInterest, ScaleType scaleType=ScaleType::Stretch, VerticalAlignmentType vAlign=VerticalAlignmentType::Center, HorizontalAlignmentType hAlign=HorizontalAlignmentType::Center)
CYISceneNode * GetUnstagedScene(size_t index) const
bool GetSceneLayerIndex(const CYIString &name, size_t &layerIndex)
void UpdateBackground()
bool MoveFocus(CYIFocus::Direction direction, const CYIFocusSearchOptions &options=CYIFocusSearchOptions())
CYISceneNode * GetEventCaptureRootNode()
bool RemoveGlobalEventListener(CYIEvent::Type eventType, CYIEventHandler *pListener, CYIEventTarget::Phase phase=CYIEventTarget::Phase::Bubble)
MissingClassHandlingMode
Optional fallback rules for missing view types during scene loading.
Definition: YiSceneManager.h:145
bool IsDrawSkipEnabled() const
A view template defines information about a view, so it can be built automatically.
Definition: YiViewTemplate.h:29
A scene node is the base type for all nodes which are used by the scene manager; it is an integral pa...
Definition: YiSceneNode.h:105
void UpdateUnstagedScenes()
void SetBackgroundColor(const CYIColor &color)
FocusRootRule
Definition: YiFocus.h:60
void SetPointerCaptureNode(CYISceneNode *pNode, uint8_t pointerID)
size_t GetStagedSceneCount() const
bool Layout(CYISceneNode *pNode)
Definition: YiSignalHandler.h:175
std::unique_ptr< CYISceneView > LoadScene(const CYIString &filename, ScaleType scaleType=ScaleType::Stretch, VerticalAlignmentType vAlign=VerticalAlignmentType::Center, HorizontalAlignmentType hAlign=HorizontalAlignmentType::Center, MissingClassHandlingMode missingHandlingMode=MissingClassHandlingMode::Abort, CYICameraFactory cameraFactory=nullptr)
size_t GetUnstagedSceneCount() const
bool UpdateSceneProperties(const CYIString &name, LayerType layerType=LayerType::Opaque, const CYIViewport *pCustomViewport=nullptr)
std::function< std::unique_ptr< CYIAbstractCameraSceneNode >(CYISceneManager *pSceneManager, const std::shared_ptr< CYIViewTemplate > &pViewTemplate, CYISceneView *pRootComposition)> CYICameraFactory
Definition: YiSceneManager.h:52
const CYIColor & GetBackgroundColor()
bool DispatchEvent(const std::shared_ptr< CYIEventDispatcher > &pDispatcher, CYIEvent *pEvent, CYISceneNode *pTarget)
virtual bool HandleEvent(const std::shared_ptr< CYIEventDispatcher > &pDispatcher, CYIEvent *pEvent) override
std::vector< CYISceneNode * > GetScenes() const
void ShowScene(const CYIString &name)
CYISignal< const CYIString &, CYISceneNode * > SceneStaged
Definition: YiSceneManager.h:652
CYISceneNode * GetPointerCaptureNode(uint8_t pointerID)
IYIPropertyChangeMonitor * GetPropertyChangeMonitor()
std::unique_ptr< CYISceneNode > RemoveScene(CYISceneNode *pSceneNode)
void SetPropertyChangeMonitor(IYIPropertyChangeMonitor *pMonitor)
bool CanBeFocused(const CYISceneView *pView) const
A class used to represent a color value.
Definition: YiColor.h:35
std::vector< CYISceneNode * > GetStagedScenes() const
Definition: YiFocusEngine.h:26
Signals and slots are a thread-safe and flexible communication framework that will allow various obje...
Definition: YiSignal.h:169
friend class CYISceneManagerPriv
Definition: YiSceneManager.h:85
void UpdateAllScenes()
void SetDrawSkipEnabled(bool enabled)
void UpdateStagedScenes()
void UpdateScene(CYISceneView *pRoot)
const int32_t YI_LONG_PRESS_MOVE_TOLERANCE
Definition: YiSceneManager.h:47
Stores data related to a user Action event.
Definition: YiActionEvent.h:19
Type
The event type of the CYIEvent class instance.
Definition: YiEvent.h:34
bool IsSceneStaged(const CYIString &name) const
HorizontalAlignmentType
Horizontal alignment.
Definition: YiSceneManager.h:133
bool Update(bool forceDirty, bool forceRender=false)
void QueueTimelineForPlayback(CYITimeline *pTimeline)
IYIEventMonitor * GetEventMonitor()
void HideScene(const CYIString &name)
friend class CYISceneNodeUtilityPriv
Definition: YiSceneManager.h:86