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

   1 //
   2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
   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 // CLASS HEADER
  18 #include <dali/internal/event/common/stage-impl.h>
  19
  20 // EXTERNAL INCLUDES
  21 #include <algorithm>
  22
  23 // INTERNAL INCLUDES
  24 #include <dali/integration-api/system-overlay.h>
  25 #include <dali/internal/event/actors/layer-impl.h>
  26 #include <dali/internal/event/actors/layer-list.h>
  27 #include <dali/internal/event/actors/camera-actor-impl.h>
  28 #include <dali/internal/event/actor-attachments/camera-attachment-impl.h>
  29 #include <dali/internal/event/common/system-overlay-impl.h>
  30 #include <dali/internal/event/common/thread-local-storage.h>
  31 #include <dali/internal/event/common/property-notification-manager.h>
  32 #include <dali/internal/event/render-tasks/render-task-list-impl.h>
  33 #include <dali/internal/update/nodes/node.h>
  34 #include <dali/internal/event/common/object-registry-impl.h>
  35 #include <dali/integration-api/platform-abstraction.h>
  36 #include <dali/public-api/common/constants.h>
  37 #include <dali/public-api/render-tasks/render-task-list.h>
  38
  39 #ifdef DYNAMICS_SUPPORT
  40 #include <dali/internal/event/dynamics/dynamics-world-config-impl.h>
  41 #include <dali/internal/event/dynamics/dynamics-world-impl.h>
  42 #include <dali/integration-api/dynamics/dynamics-factory-intf.h>
  43 #include <dali/integration-api/dynamics/dynamics-world-settings.h>
  44 #endif
  45
  46 using namespace std;
  47 using namespace boost;
  48
  49 using Dali::Internal::SceneGraph::Node;
  50
  51 namespace Dali
  52 {
  53
  54 namespace Internal
  55 {
  56
  57 namespace
  58 {
  59
  60 const float DEFAULT_STEREO_BASE( 65.0f );
  61
  62 } // unnamed namespace
  63
  64 StagePtr Stage::New( AnimationPlaylist& playlist,
  65                      PropertyNotificationManager& propertyNotificationManager,
  66                      SceneGraph::UpdateManager& updateManager,
  67                      NotificationManager& notificationManager )
  68 {
  69   return StagePtr( new Stage( playlist, propertyNotificationManager, updateManager, notificationManager ) );
  70 }
  71
  72 void Stage::Initialize()
  73 {
  74   mObjectRegistry = ObjectRegistry::New();
  75
  76   // Create the ordered list of layers
  77   mLayerList = LayerList::New( *this, false/*not system-level*/ );
  78
  79   // The stage owns the default layer
  80   mRootLayer = Layer::NewRoot( *this, *mLayerList, mUpdateManager, false/*not system-level*/ );
  81   mRootLayer->SetName("RootLayer");
  82
  83   // Create the default camera actor first; this is needed by the RenderTaskList
  84   CreateDefaultCameraActor();
  85
  86   // Create the list of render-tasks
  87   mRenderTaskList = RenderTaskList::New( mUpdateManager, *this, false/*not system-level*/ );
  88
  89   // Create the default render-task
  90   Dali::RenderTask defaultRenderTask = mRenderTaskList->CreateTask();
  91 }
  92
  93 void Stage::Uninitialize()
  94 {
  95   // Remove actors added to SystemOverlay
  96   delete mSystemOverlay;
  97   mSystemOverlay = NULL;
  98
  99   if( mDefaultCamera )
 100   {
 101     Remove(*(mDefaultCamera.Get()));
 102   }
 103
 104   if( mRootLayer )
 105   {
 106     // we are closing down so just delete the root, no point emit disconnect
 107     // signals or send messages to update
 108     mRootLayer.Reset();
 109   }
 110 }
 111
 112 StagePtr Stage::GetCurrent()
 113 {
 114   return ThreadLocalStorage::Get().GetCurrentStage();
 115 }
 116
 117 bool Stage::IsInstalled()
 118 {
 119   return ThreadLocalStorage::Created();
 120 }
 121
 122 ObjectRegistry& Stage::GetObjectRegistry()
 123 {
 124   return *mObjectRegistry;
 125 }
 126
 127 Layer& Stage::GetRootActor()
 128 {
 129   return *mRootLayer;
 130 }
 131
 132 SceneGraph::UpdateManager& Stage::GetUpdateManager()
 133 {
 134   return mUpdateManager;
 135 }
 136
 137 EventToUpdate& Stage::GetUpdateInterface()
 138 {
 139   return mUpdateManager.GetEventToUpdate();
 140 }
 141
 142 AnimationPlaylist& Stage::GetAnimationPlaylist()
 143 {
 144   return mAnimationPlaylist;
 145 }
 146
 147 PropertyNotificationManager& Stage::GetPropertyNotificationManager()
 148 {
 149   return mPropertyNotificationManager;
 150 }
 151
 152 void Stage::Add( Actor& actor )
 153 {
 154   mRootLayer->Add( actor );
 155 }
 156
 157 void Stage::Remove( Actor& actor )
 158 {
 159   mRootLayer->Remove( actor );
 160 }
 161
 162 void Stage::SetSize(float width, float height)
 163 {
 164   // Internally we want to report the actual size of the stage.
 165   mSize.width  = width;
 166   mSize.height = height;
 167
 168   // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position.
 169   mDefaultCamera->SetPerspectiveProjection( mSize );
 170
 171   // The depth of the stage gets set to the maximun of these values
 172   mRootLayer->SetSize( mSize );
 173
 174   // Repeat for SystemOverlay actors
 175   if( mSystemOverlay )
 176   {
 177     mSystemOverlay->GetImpl()->SetSize( mSize.width, mSize.height );
 178   }
 179
 180   SetDefaultSurfaceRectMessage( mUpdateManager, Rect<int>( 0, 0, width, height ) );
 181 }
 182
 183 Vector2 Stage::GetSize() const
 184 {
 185   return mSize;
 186 }
 187
 188 RenderTaskList& Stage::GetRenderTaskList() const
 189 {
 190   return *mRenderTaskList;
 191 }
 192
 193 void Stage::CreateDefaultCameraActor()
 194 {
 195   // The default camera attributes and position is such that
 196   // children of the default layer, can be positioned at (0,0) and
 197   // be at the top-left of the viewport.
 198   mDefaultCamera = CameraActor::New( Size::ZERO );
 199   mDefaultCamera->SetParentOrigin(ParentOrigin::CENTER);
 200   Add(*(mDefaultCamera.Get()));
 201 }
 202
 203 Actor& Stage::GetDefaultRootActor()
 204 {
 205   return *mRootLayer;
 206 }
 207
 208 CameraActor& Stage::GetDefaultCameraActor()
 209 {
 210   return *mDefaultCamera;
 211 }
 212
 213 unsigned int Stage::GetLayerCount() const
 214 {
 215   return mLayerList->GetLayerCount();
 216 }
 217
 218 Dali::Layer Stage::GetLayer( unsigned int depth ) const
 219 {
 220   return Dali::Layer(mLayerList->GetLayer( depth ));
 221 }
 222
 223 Dali::Layer Stage::GetRootLayer() const
 224 {
 225   return Dali::Layer( mRootLayer.Get() );
 226 }
 227
 228 LayerList& Stage::GetLayerList()
 229 {
 230   return *mLayerList;
 231 }
 232
 233 Integration::SystemOverlay& Stage::GetSystemOverlay()
 234 {
 235   // Lazily create system-level if requested
 236   if( !mSystemOverlay )
 237   {
 238     mSystemOverlay = new Integration::SystemOverlay( SystemOverlay::New( *this ) );
 239     DALI_ASSERT_ALWAYS( NULL != mSystemOverlay && "Failed to create system overlay" );
 240
 241     mSystemOverlay->GetImpl()->SetSize( mSize.width, mSize.height );
 242   }
 243
 244   return *mSystemOverlay;
 245 }
 246
 247 SystemOverlay* Stage::GetSystemOverlayInternal()
 248 {
 249   SystemOverlay* overlay( NULL );
 250
 251   if( mSystemOverlay )
 252   {
 253     overlay = mSystemOverlay->GetImpl();
 254   }
 255
 256   return overlay;
 257 }
 258
 259 void Stage::SetViewMode( ViewMode viewMode )
 260 {
 261   if( mViewMode != viewMode )
 262   {
 263     DALI_LOG_INFO( Debug::Filter::gActor, Debug::Concise, "View mode changed from %d to %d\n", mViewMode, viewMode);
 264
 265     const float stereoBase( ( (mStereoBase / 25.4f) * GetDpi().x ) * 0.5f );
 266
 267     if( mViewMode == MONO )
 268     {
 269       mDefaultCamera->SetRotation( Degree( 180.0f ), Vector3::YAXIS );
 270       mRenderTaskList->GetTask(0).SetSourceActor( Dali::Actor() );
 271
 272       mLeftCamera = CameraActor::New( Size::ZERO );
 273       mLeftCamera->SetParentOrigin( ParentOrigin::CENTER );
 274       mLeftCamera->SetPerspectiveProjection( mSize, stereoBase );
 275       mLeftCamera->SetPosition( Vector3( stereoBase, 0.0f, 0.0f ) );
 276       mDefaultCamera->Add( *mLeftCamera.Get() );
 277       mLeftRenderTask = mRenderTaskList->CreateTask();
 278       mLeftRenderTask.SetCameraActor( Dali::CameraActor( mLeftCamera.Get() ) );
 279       mLeftCamera->SetType( Dali::Camera::FREE_LOOK );
 280
 281       mRightCamera = CameraActor::New( Size::ZERO );
 282       mRightCamera->SetParentOrigin( ParentOrigin::CENTER );
 283       mRightCamera->SetPerspectiveProjection( mSize, -stereoBase );
 284       mRightCamera->SetPosition( Vector3( -stereoBase, 0.0f, 0.0f ) );
 285       mDefaultCamera->Add( *mRightCamera.Get() );
 286       mRightRenderTask = mRenderTaskList->CreateTask();
 287       mRightRenderTask.SetCameraActor( Dali::CameraActor( mRightCamera.Get() ) );
 288       mRightCamera->SetType( Dali::Camera::FREE_LOOK );
 289     }
 290
 291     // save new mode
 292     mViewMode = viewMode;
 293
 294     switch( viewMode )
 295     {
 296       case MONO:
 297       {
 298         // delete extra stereoscopic render tasks and cameras
 299         mRenderTaskList->RemoveTask( mLeftRenderTask );
 300         mDefaultCamera->Remove( *mLeftCamera.Get() );
 301         mLeftRenderTask.Reset();
 302         mLeftCamera.Reset();
 303         mRenderTaskList->RemoveTask( mRightRenderTask );
 304         mDefaultCamera->Remove( *mRightCamera.Get() );
 305         mRightRenderTask.Reset();
 306         mRightCamera.Reset();
 307
 308         mDefaultCamera->SetRotation( Degree( 0.0f ), Vector3::YAXIS );
 309         mDefaultCamera->SetType( Dali::Camera::LOOK_AT_TARGET );
 310         mRenderTaskList->GetTask(0).SetSourceActor( Dali::Layer(mRootLayer.Get()) );
 311         break;
 312       }
 313       case STEREO_HORIZONTAL:
 314       {
 315         mLeftRenderTask.SetViewport( Viewport(0, 0, mSize.width, mSize.height * 0.5f ) );
 316         mRightRenderTask.SetViewport( Viewport(0, mSize.height * 0.5f, mSize.width, mSize.height * 0.5f) );
 317         break;
 318       }
 319       case STEREO_VERTICAL:
 320       {
 321         mLeftRenderTask.SetViewport( Viewport(0, 0, mSize.width * 0.5f, mSize.height ) );
 322         mRightRenderTask.SetViewport( Viewport(mSize.width * 0.5f, 0, mSize.width * 0.5f, mSize.height ) );
 323         break;
 324       }
 325       case STEREO_INTERLACED:
 326       {
 327         break;
 328       }
 329     }
 330   }
 331 }
 332
 333 ViewMode Stage::GetViewMode() const
 334 {
 335   return mViewMode;
 336 }
 337
 338 void Stage::SetStereoBase( float stereoBase )
 339 {
 340   if( ! Equals( mStereoBase, stereoBase ) )
 341   {
 342     DALI_LOG_INFO( Debug::Filter::gActor, Debug::Concise, "old( %.2f) new(%.2f)", mStereoBase, stereoBase );
 343     mStereoBase = stereoBase;
 344
 345     if( mViewMode != MONO )
 346     {
 347       stereoBase *= 0.5f;
 348       mLeftCamera->SetX( stereoBase );
 349       mLeftCamera->SetPerspectiveProjection( mSize, stereoBase );
 350       mRightCamera->SetX( -stereoBase );
 351       mRightCamera->SetPerspectiveProjection( mSize, -stereoBase );
 352     }
 353   }
 354 }
 355
 356 float Stage::GetStereoBase() const
 357 {
 358   return mStereoBase;
 359 }
 360
 361 void Stage::SetBackgroundColor(Vector4 color)
 362 {
 363   // Cache for public GetBackgroundColor()
 364   mBackgroundColor = color;
 365
 366   // Send message to change color in next frame
 367   SetBackgroundColorMessage( mUpdateManager, color );
 368 }
 369
 370 Vector4 Stage::GetBackgroundColor() const
 371 {
 372   return mBackgroundColor;
 373 }
 374
 375 Vector2 Stage::GetDpi() const
 376 {
 377   return mDpi;
 378 }
 379
 380 void Stage::SetDpi(Vector2 dpi)
 381 {
 382   mDpi = dpi;
 383 }
 384
 385 #ifdef DYNAMICS_SUPPORT
 386
 387 DynamicsNotifier& Stage::GetDynamicsNotifier()
 388 {
 389   return mDynamicsNotifier;
 390 }
 391
 392 DynamicsWorldPtr Stage::InitializeDynamics(DynamicsWorldConfigPtr config)
 393 {
 394   if( !mDynamicsFactory )
 395   {
 396     mDynamicsFactory = ThreadLocalStorage::Get().GetPlatformAbstraction().GetDynamicsFactory();
 397   }
 398
 399   if( mDynamicsFactory && !mDynamicsWorld )
 400   {
 401     if( mDynamicsFactory->InitializeDynamics( *(config->GetSettings()) ) )
 402     {
 403       mDynamicsWorld = DynamicsWorld::New();
 404       mDynamicsWorld->Initialize( *this, *mDynamicsFactory, config );
 405     }
 406   }
 407   return mDynamicsWorld;
 408 }
 409
 410 DynamicsWorldPtr Stage::GetDynamicsWorld()
 411 {
 412   return mDynamicsWorld;
 413 }
 414
 415 void Stage::TerminateDynamics()
 416 {
 417   if( mDynamicsWorld )
 418   {
 419     mDynamicsWorld->Terminate(*this);
 420     mDynamicsWorld = NULL;
 421   }
 422 }
 423
 424 #endif // DYNAMICS_SUPPORT
 425
 426 void Stage::KeepRendering( float durationSeconds )
 427 {
 428   // Send message to keep rendering
 429   KeepRenderingMessage( mUpdateManager, durationSeconds );
 430 }
 431
 432 void Stage::EmitKeyEventSignal(const KeyEvent& event)
 433 {
 434   // Emit the key event signal when no actor in the stage has gained the key input focus
 435
 436   mKeyEventSignalV2.Emit( event );
 437 }
 438
 439 void Stage::EmitEventProcessingFinishedSignal()
 440 {
 441    mEventProcessingFinishedSignalV2.Emit();
 442 }
 443
 444 void Stage::EmitTouchedSignal( const TouchEvent& touch )
 445 {
 446   mTouchedSignalV2.Emit( touch );
 447 }
 448
 449 Dali::Stage::KeyEventSignalV2& Stage::KeyEventSignal()
 450 {
 451   return mKeyEventSignalV2;
 452 }
 453
 454 Dali::Stage::EventProcessingFinishedSignalV2& Stage::EventProcessingFinishedSignal()
 455 {
 456   return mEventProcessingFinishedSignalV2;
 457 }
 458
 459 Dali::Stage::TouchedSignalV2& Stage::TouchedSignal()
 460 {
 461   return mTouchedSignalV2;
 462 }
 463
 464 Stage::Stage( AnimationPlaylist& playlist,
 465               PropertyNotificationManager& propertyNotificationManager,
 466               SceneGraph::UpdateManager& updateManager,
 467               NotificationManager& notificationManager )
 468 : mAnimationPlaylist( playlist ),
 469   mPropertyNotificationManager(propertyNotificationManager),
 470   mUpdateManager(updateManager),
 471   mNotificationManager(notificationManager),
 472   mSize(Vector2::ZERO),
 473   mBackgroundColor(Dali::Stage::DEFAULT_BACKGROUND_COLOR),
 474   mViewMode( MONO ),
 475   mStereoBase( DEFAULT_STEREO_BASE ),
 476 #ifdef DYNAMICS_SUPPORT
 477   mDynamicsFactory(NULL),
 478 #endif
 479   mSystemOverlay(NULL)
 480 {
 481 }
 482
 483 Stage::~Stage()
 484 {
 485   delete mSystemOverlay;
 486
 487   mObjectRegistry.Reset();
 488 }
 489
 490 } // namespace Internal
 491
 492 } // namespace Dali