dali/internal/event/common/stage-impl.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/event/common/stage-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <algorithm>
  23 #include <cmath>
  24 #include <cstring> // for strcmp
  25
  26 // INTERNAL INCLUDES
  27 #include <dali/integration-api/system-overlay.h>
  28 #include <dali/internal/event/actors/layer-impl.h>
  29 #include <dali/internal/event/actors/layer-list.h>
  30 #include <dali/internal/event/actors/camera-actor-impl.h>
  31 #include <dali/internal/event/actor-attachments/camera-attachment-impl.h>
  32 #include <dali/internal/event/common/system-overlay-impl.h>
  33 #include <dali/internal/event/common/thread-local-storage.h>
  34 #include <dali/internal/event/common/property-notification-manager.h>
  35 #include <dali/internal/event/render-tasks/render-task-list-impl.h>
  36 #include <dali/internal/update/nodes/node.h>
  37 #include <dali/internal/event/common/object-registry-impl.h>
  38 #include <dali/integration-api/platform-abstraction.h>
  39 #include <dali/public-api/common/constants.h>
  40 #include <dali/public-api/object/type-registry.h>
  41 #include <dali/public-api/render-tasks/render-task-list.h>
  42
  43 #ifdef DYNAMICS_SUPPORT
  44 #include <dali/internal/event/dynamics/dynamics-world-config-impl.h>
  45 #include <dali/internal/event/dynamics/dynamics-world-impl.h>
  46 #include <dali/integration-api/dynamics/dynamics-factory-intf.h>
  47 #include <dali/integration-api/dynamics/dynamics-world-settings.h>
  48 #endif
  49
  50 using Dali::Internal::SceneGraph::Node;
  51
  52 namespace Dali
  53 {
  54
  55 namespace Internal
  56 {
  57
  58 namespace
  59 {
  60
  61 const float DEFAULT_STEREO_BASE( 65.0f );
  62
  63 // Signals
  64
  65 const char* const SIGNAL_KEY_EVENT =                 "key-event";
  66 const char* const SIGNAL_EVENT_PROCESSING_FINISHED = "event-processing-finished";
  67 const char* const SIGNAL_TOUCHED =                   "touched";
  68 const char* const SIGNAL_CONTEXT_LOST =              "context-lost";
  69 const char* const SIGNAL_CONTEXT_REGAINED =          "context-regained";
  70 const char* const SIGNAL_SCENE_CREATED =             "scene-created";
  71
  72 TypeRegistration mType( typeid(Dali::Stage), typeid(Dali::BaseHandle), NULL );
  73
  74 SignalConnectorType signalConnector1( mType, SIGNAL_KEY_EVENT,                 &Stage::DoConnectSignal );
  75 SignalConnectorType signalConnector2( mType, SIGNAL_EVENT_PROCESSING_FINISHED, &Stage::DoConnectSignal );
  76 SignalConnectorType signalConnector3( mType, SIGNAL_TOUCHED,                   &Stage::DoConnectSignal );
  77 SignalConnectorType signalConnector4( mType, SIGNAL_CONTEXT_LOST,              &Stage::DoConnectSignal );
  78 SignalConnectorType signalConnector5( mType, SIGNAL_CONTEXT_REGAINED,          &Stage::DoConnectSignal );
  79 SignalConnectorType signalConnector6( mType, SIGNAL_SCENE_CREATED,             &Stage::DoConnectSignal );
  80
  81 } // unnamed namespace
  82
  83 StagePtr Stage::New( AnimationPlaylist& playlist,
  84                      PropertyNotificationManager& propertyNotificationManager,
  85                      SceneGraph::UpdateManager& updateManager,
  86                      NotificationManager& notificationManager )
  87 {
  88   return StagePtr( new Stage( playlist, propertyNotificationManager, updateManager, notificationManager ) );
  89 }
  90
  91 void Stage::Initialize()
  92 {
  93   mObjectRegistry = ObjectRegistry::New();
  94
  95   // Create the ordered list of layers
  96   mLayerList = LayerList::New( mUpdateManager, false/*not system-level*/ );
  97
  98   // The stage owns the default layer
  99   mRootLayer = Layer::NewRoot( *mLayerList, mUpdateManager, false/*not system-level*/ );
 100   mRootLayer->SetName("RootLayer");
 101
 102   // Create the default camera actor first; this is needed by the RenderTaskList
 103   CreateDefaultCameraActor();
 104
 105   // Create the list of render-tasks
 106   mRenderTaskList = RenderTaskList::New( *this, *this, false/*not system-level*/ );
 107
 108   // Create the default render-task
 109   Dali::RenderTask defaultRenderTask = mRenderTaskList->CreateTask();
 110 }
 111
 112 void Stage::Uninitialize()
 113 {
 114   // Remove actors added to SystemOverlay
 115   delete mSystemOverlay;
 116   mSystemOverlay = NULL;
 117
 118   if( mDefaultCamera )
 119   {
 120     // its enough to release the handle so the object is released
 121     // don't need to remove it from root actor as root actor will delete the object
 122     mDefaultCamera.Reset();
 123   }
 124
 125   if( mRootLayer )
 126   {
 127     // we are closing down so just delete the root, no point emit disconnect
 128     // signals or send messages to update
 129     mRootLayer.Reset();
 130   }
 131 }
 132
 133 StagePtr Stage::GetCurrent()
 134 {
 135   StagePtr stage( NULL );
 136   // no checking in this version
 137   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 138   if( tls )
 139   {
 140     stage = tls->GetCurrentStage();
 141   }
 142   return stage;
 143 }
 144
 145 bool Stage::IsInstalled()
 146 {
 147   return ThreadLocalStorage::Created();
 148 }
 149
 150 ObjectRegistry& Stage::GetObjectRegistry()
 151 {
 152   return *mObjectRegistry;
 153 }
 154
 155 void Stage::RegisterObject( Dali::BaseObject* object )
 156 {
 157   mObjectRegistry->RegisterObject( object );
 158 }
 159
 160 void Stage::UnregisterObject( Dali::BaseObject* object )
 161 {
 162   mObjectRegistry->UnregisterObject( object );
 163 }
 164
 165 Layer& Stage::GetRootActor()
 166 {
 167   return *mRootLayer;
 168 }
 169
 170 AnimationPlaylist& Stage::GetAnimationPlaylist()
 171 {
 172   return mAnimationPlaylist;
 173 }
 174
 175 PropertyNotificationManager& Stage::GetPropertyNotificationManager()
 176 {
 177   return mPropertyNotificationManager;
 178 }
 179
 180 void Stage::Add( Actor& actor )
 181 {
 182   mRootLayer->Add( actor );
 183 }
 184
 185 void Stage::Remove( Actor& actor )
 186 {
 187   mRootLayer->Remove( actor );
 188 }
 189
 190 void Stage::SetSize(float width, float height)
 191 {
 192   // Internally we want to report the actual size of the stage.
 193   mSize.width  = width;
 194   mSize.height = height;
 195
 196   // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position.
 197   mDefaultCamera->SetPerspectiveProjection( mSize );
 198
 199   // The depth of the stage gets set to the maximun of these values
 200   mRootLayer->SetSize( mSize );
 201
 202   // Repeat for SystemOverlay actors
 203   if( mSystemOverlay )
 204   {
 205     mSystemOverlay->GetImpl()->SetSize( mSize.width, mSize.height );
 206   }
 207
 208   SetDefaultSurfaceRectMessage( mUpdateManager, Rect<int>( 0, 0, width, height ) );
 209 }
 210
 211 Vector2 Stage::GetSize() const
 212 {
 213   return mSize;
 214 }
 215
 216 RenderTaskList& Stage::GetRenderTaskList() const
 217 {
 218   return *mRenderTaskList;
 219 }
 220
 221 void Stage::CreateDefaultCameraActor()
 222 {
 223   // The default camera attributes and position is such that
 224   // children of the default layer, can be positioned at (0,0) and
 225   // be at the top-left of the viewport.
 226   mDefaultCamera = CameraActor::New( Size::ZERO );
 227   mDefaultCamera->SetParentOrigin(ParentOrigin::CENTER);
 228   Add(*(mDefaultCamera.Get()));
 229 }
 230
 231 Actor& Stage::GetDefaultRootActor()
 232 {
 233   return *mRootLayer;
 234 }
 235
 236 CameraActor& Stage::GetDefaultCameraActor()
 237 {
 238   return *mDefaultCamera;
 239 }
 240
 241 unsigned int Stage::GetLayerCount() const
 242 {
 243   return mLayerList->GetLayerCount();
 244 }
 245
 246 Dali::Layer Stage::GetLayer( unsigned int depth ) const
 247 {
 248   return Dali::Layer(mLayerList->GetLayer( depth ));
 249 }
 250
 251 Dali::Layer Stage::GetRootLayer() const
 252 {
 253   return Dali::Layer( mRootLayer.Get() );
 254 }
 255
 256 LayerList& Stage::GetLayerList()
 257 {
 258   return *mLayerList;
 259 }
 260
 261 Integration::SystemOverlay& Stage::GetSystemOverlay()
 262 {
 263   // Lazily create system-level if requested
 264   if( !mSystemOverlay )
 265   {
 266     mSystemOverlay = new Integration::SystemOverlay( SystemOverlay::New( *this ) );
 267     DALI_ASSERT_ALWAYS( NULL != mSystemOverlay && "Failed to create system overlay" );
 268
 269     mSystemOverlay->GetImpl()->SetSize( mSize.width, mSize.height );
 270   }
 271
 272   return *mSystemOverlay;
 273 }
 274
 275 SystemOverlay* Stage::GetSystemOverlayInternal()
 276 {
 277   SystemOverlay* overlay( NULL );
 278
 279   if( mSystemOverlay )
 280   {
 281     overlay = mSystemOverlay->GetImpl();
 282   }
 283
 284   return overlay;
 285 }
 286
 287 void Stage::SetViewMode( ViewMode viewMode )
 288 {
 289   if( mViewMode != viewMode )
 290   {
 291     DALI_LOG_INFO( Debug::Filter::gActor, Debug::Concise, "View mode changed from %d to %d\n", mViewMode, viewMode);
 292
 293     if( mViewMode == MONO )
 294     {
 295       mDefaultCamera->SetOrientation( Dali::ANGLE_180, Vector3::YAXIS );
 296       mRenderTaskList->GetTask(0).SetSourceActor( Dali::Actor() );
 297
 298       //Create camera and RenderTask for left eye
 299       mLeftCamera = CameraActor::New( Size::ZERO );
 300       mLeftCamera->SetParentOrigin( ParentOrigin::CENTER );
 301       mDefaultCamera->Add( *mLeftCamera.Get() );
 302       mLeftRenderTask = mRenderTaskList->CreateTask();
 303       mLeftRenderTask.SetCameraActor( Dali::CameraActor( mLeftCamera.Get() ) );
 304       mLeftCamera->SetType( Dali::Camera::FREE_LOOK );
 305
 306       //Create camera and RenderTask for right eye
 307       mRightCamera = CameraActor::New( Size::ZERO );
 308       mRightCamera->SetParentOrigin( ParentOrigin::CENTER );
 309       mDefaultCamera->Add( *mRightCamera.Get() );
 310       mRightRenderTask = mRenderTaskList->CreateTask();
 311       mRightRenderTask.SetClearColor( Vector4( 1.0f,0.0f,0.0f,1.0f));
 312
 313       mRightRenderTask.SetCameraActor( Dali::CameraActor( mRightCamera.Get() ) );
 314       mRightCamera->SetType( Dali::Camera::FREE_LOOK );
 315     }
 316
 317     // save new mode
 318     mViewMode = viewMode;
 319
 320     switch( viewMode )
 321     {
 322       case MONO:
 323       {
 324         // delete extra stereoscopic render tasks and cameras
 325         mRenderTaskList->RemoveTask( mLeftRenderTask );
 326         mDefaultCamera->Remove( *mLeftCamera.Get() );
 327         mLeftRenderTask.Reset();
 328         mLeftCamera.Reset();
 329         mRenderTaskList->RemoveTask( mRightRenderTask );
 330         mDefaultCamera->Remove( *mRightCamera.Get() );
 331         mRightRenderTask.Reset();
 332         mRightCamera.Reset();
 333         mDefaultCamera->SetOrientation( Dali::ANGLE_0, Vector3::YAXIS );
 334         mDefaultCamera->SetType( Dali::Camera::LOOK_AT_TARGET );
 335         mRenderTaskList->GetTask(0).SetSourceActor( Dali::Layer(mRootLayer.Get()) );
 336
 337         break;
 338       }
 339       case STEREO_HORIZONTAL:
 340       {
 341         //Stereo mode with horizontal split is for landscape mode. That's the reason for the cameras being rotated
 342         //Top camera renders the scene as seen from the right eye and bottom camera as seen from left.
 343
 344         //Calculate separation in pixels along vertical axis ( mStereoBase is defined in millimetres )
 345         const float stereoBase( ( (mStereoBase / 25.4f) * GetDpi().y ) * 0.5f );
 346
 347         //Calculate aspect ratio
 348         float aspect = mSize.width / (mSize.height * 0.5f);
 349
 350         mLeftCamera->SetPerspectiveProjection( mSize, Vector2( 0.0f,stereoBase) );
 351         mLeftCamera->SetAspectRatio( aspect );
 352
 353         mLeftCamera->SetOrientation( -Dali::ANGLE_90, Vector3::ZAXIS );
 354         mLeftCamera->SetPosition( Vector3( stereoBase, 0.0f, 0.0f ) );
 355         mLeftRenderTask.SetViewport( Viewport(0, mSize.height * 0.5f, mSize.width, mSize.height * 0.5f) );
 356
 357         mRightCamera->SetPerspectiveProjection( mSize, Vector2( 0.0,  -stereoBase) );
 358         mRightCamera->SetAspectRatio( aspect );
 359         mRightCamera->SetOrientation( -Dali::ANGLE_90, Vector3::ZAXIS );
 360         mRightCamera->SetPosition( Vector3(-stereoBase, 0.0f, 0.0f ) );
 361         mRightRenderTask.SetViewport( Viewport(0, 0, mSize.width, mSize.height * 0.5f ) );
 362
 363         break;
 364       }
 365       case STEREO_VERTICAL:
 366       {
 367         //Calculate separation in pixels along horizontal axis
 368         const float stereoBase( ( (mStereoBase / 25.4f) * GetDpi().x ) * 0.5f );
 369
 370         //Recalculate fov based on viewport size
 371         const float fov = 2.0f * std::atan(  mSize.y / (2.0f * std::max( mSize.x*0.5f, mSize.y )) );
 372
 373         mLeftCamera->SetPerspectiveProjection( Size( mSize.x * 0.5f, mSize.y ), Vector2(stereoBase,0.0f) );
 374         mLeftCamera->SetFieldOfView( fov );
 375         mLeftCamera->SetOrientation( Dali::ANGLE_0, Vector3::ZAXIS );
 376         mLeftCamera->SetPosition( Vector3( stereoBase, 0.0f, 0.0f ) );
 377         mLeftRenderTask.SetViewport( Viewport(0, 0, mSize.width * 0.5f, mSize.height ) );
 378
 379         mRightCamera->SetPerspectiveProjection( Size( mSize.x * 0.5f, mSize.y ), Vector2(-stereoBase,0.0f) );
 380         mRightCamera->SetFieldOfView( fov );
 381         mRightCamera->SetOrientation( Dali::ANGLE_0, Vector3::ZAXIS );
 382         mRightCamera->SetPosition( Vector3( -stereoBase, 0.0f, 0.0f ) );
 383         mRightRenderTask.SetViewport( Viewport(mSize.width * 0.5f, 0, mSize.width * 0.5f, mSize.height ) );
 384
 385         break;
 386       }
 387       case STEREO_INTERLACED:
 388       {
 389         break;
 390       }
 391     }
 392   }
 393 }
 394
 395 ViewMode Stage::GetViewMode() const
 396 {
 397   return mViewMode;
 398 }
 399
 400 void Stage::SetStereoBase( float stereoBase )
 401 {
 402   if( ! Equals( mStereoBase, stereoBase ) )
 403   {
 404     DALI_LOG_INFO( Debug::Filter::gActor, Debug::Concise, "old( %.2f) new(%.2f)", mStereoBase, stereoBase );
 405     mStereoBase = stereoBase;
 406
 407     switch( mViewMode  )
 408     {
 409       case STEREO_HORIZONTAL:
 410       {
 411         stereoBase = mStereoBase / 25.4f * GetDpi().y * 0.5f;
 412         float aspect = mSize.width / (mSize.height * 0.5f);
 413
 414         mLeftCamera->SetPerspectiveProjection( mSize, Vector2( 0.0, stereoBase) );
 415         mLeftCamera->SetAspectRatio( aspect );
 416         mLeftCamera->SetPosition( Vector3( stereoBase, 0.0f, 0.0f ) );
 417
 418         mRightCamera->SetPerspectiveProjection( mSize, Vector2( 0.0, -stereoBase) );
 419         mRightCamera->SetAspectRatio( aspect );
 420         mRightCamera->SetPosition( Vector3(-stereoBase, 0.0f, 0.0f ) );
 421
 422         break;
 423       }
 424       case STEREO_VERTICAL:
 425       {
 426         stereoBase = mStereoBase / 25.4f * GetDpi().x * 0.5f;
 427         const float fov = 2.0f * std::atan(  mSize.y / (2.0f * std::max( mSize.x*0.5f, mSize.y )) );
 428
 429         mLeftCamera->SetPerspectiveProjection( Size( mSize.x * 0.5f, mSize.y ), Vector2(stereoBase,0.0f) );
 430         mLeftCamera->SetFieldOfView( fov );
 431         mLeftCamera->SetPosition( Vector3( stereoBase, 0.0f, 0.0f ) );
 432
 433         mRightCamera->SetPerspectiveProjection( Size( mSize.x * 0.5f, mSize.y ), Vector2(-stereoBase,0.0f) );
 434         mRightCamera->SetFieldOfView( fov );
 435         mRightCamera->SetPosition( Vector3(-stereoBase, 0.0f, 0.0f ) );
 436
 437         break;
 438       }
 439       default:
 440         break;
 441     }
 442   }
 443 }
 444
 445 float Stage::GetStereoBase() const
 446 {
 447   return mStereoBase;
 448 }
 449
 450 void Stage::SetBackgroundColor(Vector4 color)
 451 {
 452   // Cache for public GetBackgroundColor()
 453   mBackgroundColor = color;
 454
 455   // Send message to change color in next frame
 456   SetBackgroundColorMessage( mUpdateManager, color );
 457 }
 458
 459 Vector4 Stage::GetBackgroundColor() const
 460 {
 461   return mBackgroundColor;
 462 }
 463
 464 Vector2 Stage::GetDpi() const
 465 {
 466   return mDpi;
 467 }
 468
 469 void Stage::SetDpi(Vector2 dpi)
 470 {
 471   mDpi = dpi;
 472 }
 473
 474 #ifdef DYNAMICS_SUPPORT
 475
 476 DynamicsNotifier& Stage::GetDynamicsNotifier()
 477 {
 478   return mDynamicsNotifier;
 479 }
 480
 481 DynamicsWorldPtr Stage::InitializeDynamics(DynamicsWorldConfigPtr config)
 482 {
 483   if( !mDynamicsFactory )
 484   {
 485     mDynamicsFactory = ThreadLocalStorage::Get().GetPlatformAbstraction().GetDynamicsFactory();
 486   }
 487
 488   if( mDynamicsFactory && !mDynamicsWorld )
 489   {
 490     if( mDynamicsFactory->InitializeDynamics( *(config->GetSettings()) ) )
 491     {
 492       mDynamicsWorld = DynamicsWorld::New();
 493       mDynamicsWorld->Initialize( *this, *mDynamicsFactory, config );
 494     }
 495   }
 496   return mDynamicsWorld;
 497 }
 498
 499 DynamicsWorldPtr Stage::GetDynamicsWorld()
 500 {
 501   return mDynamicsWorld;
 502 }
 503
 504 void Stage::TerminateDynamics()
 505 {
 506   if( mDynamicsWorld )
 507   {
 508     mDynamicsWorld->Terminate(*this);
 509     mDynamicsWorld = NULL;
 510   }
 511 }
 512
 513 #endif // DYNAMICS_SUPPORT
 514
 515 void Stage::KeepRendering( float durationSeconds )
 516 {
 517   // Send message to keep rendering
 518   KeepRenderingMessage( mUpdateManager, durationSeconds );
 519 }
 520
 521 bool Stage::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 522 {
 523   bool connected( true );
 524   Stage* stage = dynamic_cast<Stage*>(object);
 525
 526   if( 0 == strcmp( signalName.c_str(), SIGNAL_KEY_EVENT ) )
 527   {
 528     stage->KeyEventSignal().Connect( tracker, functor );
 529   }
 530   else if( 0 == strcmp( signalName.c_str(), SIGNAL_EVENT_PROCESSING_FINISHED ) )
 531   {
 532     stage->EventProcessingFinishedSignal().Connect( tracker, functor );
 533   }
 534   else if( 0 == strcmp( signalName.c_str(), SIGNAL_TOUCHED ) )
 535   {
 536     stage->TouchedSignal().Connect( tracker, functor );
 537   }
 538   else if( 0 == strcmp( signalName.c_str(), SIGNAL_CONTEXT_LOST ) )
 539   {
 540     stage->ContextLostSignal().Connect( tracker, functor );
 541   }
 542   else if( 0 == strcmp( signalName.c_str(), SIGNAL_CONTEXT_REGAINED ) )
 543   {
 544     stage->ContextRegainedSignal().Connect( tracker, functor );
 545   }
 546   else if( 0 == strcmp( signalName.c_str(), SIGNAL_SCENE_CREATED ) )
 547   {
 548     stage->SceneCreatedSignal().Connect( tracker, functor );
 549   }
 550   else
 551   {
 552     // signalName does not match any signal
 553     connected = false;
 554   }
 555
 556   return connected;
 557 }
 558
 559 void Stage::EmitKeyEventSignal(const KeyEvent& event)
 560 {
 561   // Emit the key event signal when no actor in the stage has gained the key input focus
 562
 563   mKeyEventSignal.Emit( event );
 564 }
 565
 566 void Stage::EmitEventProcessingFinishedSignal()
 567 {
 568    mEventProcessingFinishedSignal.Emit();
 569 }
 570
 571 void Stage::EmitTouchedSignal( const TouchEvent& touch )
 572 {
 573   mTouchedSignal.Emit( touch );
 574 }
 575
 576
 577 void Stage::EmitSceneCreatedSignal()
 578 {
 579   mSceneCreatedSignal.Emit();
 580 }
 581
 582 Dali::Stage::KeyEventSignalType& Stage::KeyEventSignal()
 583 {
 584   return mKeyEventSignal;
 585 }
 586
 587 Dali::Stage::EventProcessingFinishedSignalType& Stage::EventProcessingFinishedSignal()
 588 {
 589   return mEventProcessingFinishedSignal;
 590 }
 591
 592 Dali::Stage::TouchedSignalType& Stage::TouchedSignal()
 593 {
 594   return mTouchedSignal;
 595 }
 596
 597 Dali::Stage::ContextStatusSignal& Stage::ContextLostSignal()
 598 {
 599   return mContextLostSignal;
 600 }
 601
 602 Dali::Stage::ContextStatusSignal& Stage::ContextRegainedSignal()
 603 {
 604   return mContextRegainedSignal;
 605 }
 606
 607 Dali::Stage::SceneCreatedSignalType& Stage::SceneCreatedSignal()
 608 {
 609   return mSceneCreatedSignal;
 610 }
 611
 612 void Stage::NotifyContextLost()
 613 {
 614   mContextLostSignal.Emit();
 615 }
 616
 617 void Stage::NotifyContextRegained()
 618 {
 619   mContextRegainedSignal.Emit();
 620 }
 621
 622 Stage::Stage( AnimationPlaylist& playlist,
 623               PropertyNotificationManager& propertyNotificationManager,
 624               SceneGraph::UpdateManager& updateManager,
 625               NotificationManager& notificationManager )
 626 : mAnimationPlaylist( playlist ),
 627   mPropertyNotificationManager(propertyNotificationManager),
 628   mUpdateManager(updateManager),
 629   mNotificationManager(notificationManager),
 630   mSize(Vector2::ZERO),
 631   mBackgroundColor(Dali::Stage::DEFAULT_BACKGROUND_COLOR),
 632   mViewMode( MONO ),
 633   mStereoBase( DEFAULT_STEREO_BASE ),
 634 #ifdef DYNAMICS_SUPPORT
 635   mDynamicsFactory(NULL),
 636 #endif
 637   mSystemOverlay(NULL)
 638 {
 639 }
 640
 641 SceneGraph::UpdateManager& Stage::GetUpdateManager()
 642 {
 643   return mUpdateManager;
 644 }
 645
 646 unsigned int* Stage::ReserveMessageSlot( std::size_t size, bool updateScene )
 647 {
 648   return mUpdateManager.ReserveMessageSlot( size, updateScene );
 649 }
 650
 651 BufferIndex Stage::GetEventBufferIndex() const
 652 {
 653   return mUpdateManager.GetEventBufferIndex();
 654 }
 655
 656 Stage::~Stage()
 657 {
 658   delete mSystemOverlay;
 659
 660   mObjectRegistry.Reset();
 661 }
 662
 663 } // namespace Internal
 664
 665 } // namespace Dali