You.i Engine
YiSceneManager.h
Go to the documentation of this file.
1 // © You i Labs Inc. 2000-2020. 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 "framework/YiPredef.h"
10 #include "scenetree/YiSceneNode.h"
11 #include "signal/YiSignalHandler.h"
12 #include "utility/YiTimer.h"
13 
14 #include <array>
15 #include <glm/fwd.hpp>
16 #include <glm/gtc/epsilon.hpp>
17 
18 class CYIActionEvent;
19 class CYIColor;
20 class CYIFocusEngine;
22 class CYIRay;
23 class CYISceneManagerPriv;
24 class CYISceneView;
25 class CYITimeline;
26 class CYITransformSystem;
27 class CYIViewport;
28 class CYIViewTemplate;
29 class IYIEventMonitor;
30 class IYIPropertyChangeMonitor;
31 
37 const uint8_t YI_MAX_POINTER_ID = 10;
38 const int32_t YI_DELAYED_DOWN_EVENT_DELAY = 115; // 115 ms, same as Android
39 const int32_t YI_LONG_PRESS_DELAY = 1000; // 1 second
40 const int32_t YI_LONG_PRESS_MOVE_TOLERANCE = 10; // 10 pixels
41 
42 using CYICameraFactory = std::function<std::unique_ptr<CYIAbstractCameraSceneNode>(
43  CYISceneManager *pSceneManager,
44  const std::shared_ptr<CYIViewTemplate> &pViewTemplate,
45  CYISceneView *pRootComposition)>;
46 
76 {
77  friend class CYIFocusPriv;
78  friend class CYISceneManagerPriv;
80 
81 public:
89  enum class LayerType
90  {
91  Opaque,
93  };
94 
100  enum class ScaleType
101  {
102  Fill,
103  Fit,
104  Stretch,
105  ActualSize,
106  ResponsiveLayout
107  };
108 
115  {
116  Top,
117  Center,
118  Bottom
119  };
120 
127  {
128  Left,
129  Center,
130  Right
131  };
132 
139  {
140  Abort,
141  SwapWithSceneView
142  };
143 
144  CYISceneManager(std::unique_ptr<CYIFocusEngine> pFocusEngine);
145  virtual ~CYISceneManager();
146 
154  std::unique_ptr<CYISceneView> CreateScene(const YI_RECT_REL &worldRegionOfInterest,
155  ScaleType scaleType = ScaleType::Stretch,
158 
167  std::unique_ptr<CYISceneView> LoadScene(const CYIString &filename,
168  ScaleType scaleType = ScaleType::Stretch,
172  CYICameraFactory cameraFactory = nullptr);
173 
181  std::unique_ptr<CYISceneView> LoadScene(const CYIString &filename,
182  const YI_RECT_REL &screenRegion,
183  ScaleType scaleType = ScaleType::Stretch,
187  CYICameraFactory cameraFactory = nullptr);
188 
195  void UpdateScene(CYISceneView *pRoot);
196 
203  void UpdateScene(CYISceneView *pRoot,
204  ScaleType scaleType,
205  VerticalAlignmentType vAlign,
206  HorizontalAlignmentType hAlign);
207 
214  void UpdateScene(CYISceneView *pRoot,
215  const YI_RECT_REL &screenRegion,
216  ScaleType scaleType = ScaleType::Stretch,
219 
226  void UpdateStagedScenes();
227 
234  void UpdateUnstagedScenes();
235 
242  void UpdateAllScenes();
243 
249  void UpdateBackground();
250 
257  void OnSurfaceSizeChanged();
258 
267  bool GetSceneUpdateProperties(CYISceneView *pRoot, ScaleType &scaleType, VerticalAlignmentType &vAlign, HorizontalAlignmentType &hAlign) const;
268 
286  bool AddScene(const CYIString &name, std::unique_ptr<CYISceneNode> pSceneNode, size_t layerIndex = 0, LayerType layerType = LayerType::Opaque, const CYIViewport *pCustomViewport = nullptr);
287 
293  std::unique_ptr<CYISceneNode> RemoveScene(CYISceneNode *pSceneNode);
294 
298  std::unique_ptr<CYISceneNode> RemoveScene(const CYIString &name);
299 
309  bool UpdateSceneProperties(const CYIString &name, LayerType layerType = LayerType::Opaque, const CYIViewport *pCustomViewport = nullptr);
310 
318  bool GetSceneProperties(const CYIString &name, LayerType &layerType, CYIViewport &viewport) const;
319 
323  size_t GetStagedSceneCount() const;
324 
332  CYISceneNode *GetStagedScene(size_t index) const;
333 
339  CYISceneNode *GetStagedScene(const CYIString &name) const;
340 
348  std::vector<CYISceneNode *> GetStagedScenes() const;
349 
353  size_t GetUnstagedSceneCount() const;
354 
362  CYISceneNode *GetUnstagedScene(size_t index) const;
363 
369  CYISceneNode *GetUnstagedScene(const CYIString &name) const;
370 
378  std::vector<CYISceneNode *> GetUnstagedScenes() const;
379 
383  size_t GetSceneCount() const;
384 
392  CYISceneNode *GetScene(size_t index) const;
393 
399  CYISceneNode *GetScene(const CYIString &name) const;
400 
408  std::vector<CYISceneNode *> GetScenes() const;
409 
413  const CYIString &GetSceneName(CYISceneNode *pScene) const;
414 
418  void ShowScene(const CYIString &name);
419 
423  void HideScene(const CYIString &name);
424 
428  bool GetSceneLayerIndex(const CYIString &name, size_t &layerIndex);
429 
437  bool SetSceneLayerIndex(const CYIString &name, size_t layerIndex);
438 
444  bool StageScene(const CYIString &name);
445 
451  bool UnstageScene(const CYIString &name);
452 
456  bool IsSceneStaged(const CYIString &name) const;
457 
461  void DestroyScenes();
462 
468  bool Update(bool forceDirty, bool forceRender = false);
469 
477  bool Layout(CYISceneNode *pNode);
478 
484  void Draw() const;
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  std::vector<IYIRenderer::Command> m_defaultRenderList;
885 
886  bool m_layingOut;
887  bool m_shuttingDown;
888  bool m_drawSkip;
889 
890  std::unique_ptr<CYIFocusEngine> m_pFocusEngine;
891 
892  std::unique_ptr<CYISceneManagerPriv> m_pPriv;
893 
894  IYIPropertyChangeMonitor *m_pPropertyChangeMonitor;
895  IYIEventMonitor *m_pEventMonitor;
896 
897  std::unique_ptr<CYITransformSystem> m_pTransformSystem;
898 
900 };
901 
904 #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:77
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:122
void RequestRerender()
LayerType
Specifies layering rules on a scene. Transparent scenes may be drawn over other scenes.
Definition: YiSceneManager.h:89
const CYIString & GetSceneName(CYISceneNode *pScene) const
A class containing focus search options.
Definition: YiFocusSearchOptions.h:23
const int32_t YI_LONG_PRESS_DELAY
Definition: YiSceneManager.h:39
bool RequestFocus(const CYISceneView *pViewToFocus, CYIFocus::FocusRootRule focusRootRule=CYIFocus::FocusRootRule::DescendantsUpdateContext)
bool AddGlobalEventListener(CYIEvent::Type eventType, CYIEventHandler *pListener, CYIEventTarget::Phase phase=CYIEventTarget::Phase::Bubble)
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:75
Definition: YiPredef.h:291
const uint8_t YI_MAX_POINTER_ID
Definition: YiSceneManager.h:37
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:27
The base class for all view types. Views are containers of renderable elements that often define inte...
Definition: YiSceneView.h:47
VerticalAlignmentType
Vertical alignment.
Definition: YiSceneManager.h:114
CYISceneNode * GetScene(size_t index) const
Container class for Unicode strings. Conceptually, a CYIString object is a sequence of Unicode charac...
Definition: YiString.h:36
bool UnstageScene(const CYIString &name)
Definition: YiOrthographicCameraSceneNode.h:27
bool GetSceneProperties(const CYIString &name, LayerType &layerType, CYIViewport &viewport) const
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:100
CYISignal< const CYIString &, CYISceneNode * > SceneUnstaged
Definition: YiSceneManager.h:657
void DestroyScenes()
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:38
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:138
bool IsDrawSkipEnabled() const
void Draw() 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:99
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:45
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:31
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:168
friend class CYISceneManagerPriv
Definition: YiSceneManager.h:78
void UpdateAllScenes()
void SetDrawSkipEnabled(bool enabled)
void UpdateStagedScenes()
void UpdateScene(CYISceneView *pRoot)
const int32_t YI_LONG_PRESS_MOVE_TOLERANCE
Definition: YiSceneManager.h:40
Stores data related to a user Action event.
Definition: YiActionEvent.h:18
Type
The event type of the CYIEvent class instance.
Definition: YiEvent.h:33
bool IsSceneStaged(const CYIString &name) const
HorizontalAlignmentType
Horizontal alignment.
Definition: YiSceneManager.h:126
bool Update(bool forceDirty, bool forceRender=false)
void QueueTimelineForPlayback(CYITimeline *pTimeline)
IYIEventMonitor * GetEventMonitor()
void HideScene(const CYIString &name)
friend class CYISceneNodeUtilityPriv
Definition: YiSceneManager.h:79