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