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

   1 /*
   2  * Copyright (c) 2020 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/scene-impl.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/internal/event/actors/layer-impl.h>
  23 #include <dali/internal/event/actors/layer-list.h>
  24 #include <dali/internal/event/actors/camera-actor-impl.h>
  25 #include <dali/internal/event/common/thread-local-storage.h>
  26 #include <dali/internal/event/render-tasks/render-task-list-impl.h>
  27 #include <dali/internal/event/render-tasks/render-task-impl.h>
  28 #include <dali/internal/event/common/object-registry-impl.h>
  29 #include <dali/internal/update/nodes/node.h>
  30 #include <dali/internal/update/manager/update-manager.h>
  31 #include <dali/internal/update/common/scene-graph-scene.h>
  32 #include <dali/public-api/common/constants.h>
  33 #include <dali/public-api/object/type-registry.h>
  34 #include <dali/public-api/render-tasks/render-task-list.h>
  35 #include <dali/internal/event/rendering/frame-buffer-impl.h>
  36 #include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
  37
  38 using Dali::Internal::SceneGraph::Node;
  39
  40 namespace Dali
  41 {
  42
  43 namespace Internal
  44 {
  45
  46 ScenePtr Scene::New( Size size )
  47 {
  48   ScenePtr scene = new Scene;
  49
  50   // Second-phase construction
  51   scene->Initialize( size );
  52
  53   return scene;
  54 }
  55
  56 Scene::Scene()
  57 : mSceneObject( nullptr ),
  58   mSize(), // Don't set the proper value here, this will be set when the surface is set later
  59   mDpi(),
  60   mBackgroundColor( DEFAULT_BACKGROUND_COLOR ),
  61   mDepthTreeDirty( false ),
  62   mEventProcessor( *this, ThreadLocalStorage::GetInternal()->GetGestureEventProcessor() )
  63 {
  64 }
  65
  66 Scene::~Scene()
  67 {
  68   if( EventThreadServices::IsCoreRunning() && mSceneObject )
  69   {
  70     ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
  71     RemoveSceneMessage( tls->GetUpdateManager(), *mSceneObject );
  72   }
  73
  74   if( mDefaultCamera )
  75   {
  76     // its enough to release the handle so the object is released
  77     // don't need to remove it from root actor as root actor will delete the object
  78     mDefaultCamera.Reset();
  79   }
  80
  81   if( mRootLayer )
  82   {
  83     // we are closing down so just delete the root, no point emit disconnect
  84     // signals or send messages to update
  85     mRootLayer.Reset();
  86   }
  87
  88   if( mRenderTaskList )
  89   {
  90     mRenderTaskList.Reset();
  91   }
  92
  93   // No need to discard this Scene from Core, as Core stores an intrusive_ptr to this scene
  94   // When this destructor is called, the scene has either already been removed from Core or Core has already been destroyed
  95 }
  96
  97 void Scene::Initialize( Size size )
  98 {
  99   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 100
 101   DALI_ASSERT_ALWAYS( tls && "Attempt to create scene before core exists!" );
 102
 103   tls->AddScene( this );
 104
 105   SceneGraph::UpdateManager& updateManager = tls->GetUpdateManager();
 106
 107   // Create the ordered list of layers
 108   mLayerList = LayerList::New( updateManager );
 109
 110   // The scene owns the default layer
 111   mRootLayer = Layer::NewRoot( *mLayerList );
 112   mRootLayer->SetName("RootLayer");
 113   mRootLayer->SetScene( *this );
 114
 115   // The root layer needs to have a fixed resize policy (as opposed to the default USE_NATURAL_SIZE).
 116   // This stops actors parented to the stage having their relayout requests propagating
 117   // up to the root layer, and down through other children unnecessarily.
 118   mRootLayer->SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
 119
 120   // Create the default camera actor first; this is needed by the RenderTaskList
 121   // The default camera attributes and position is such that children of the default layer,
 122   // can be positioned at (0,0) and be at the top-left of the viewport.
 123   mDefaultCamera = CameraActor::New( size );
 124   mDefaultCamera->SetParentOrigin(ParentOrigin::CENTER);
 125   Add(*(mDefaultCamera.Get()));
 126
 127   // Create the list of render-tasks
 128   mRenderTaskList = RenderTaskList::New();
 129
 130   // Create the default render-task and ensure clear is enabled on it to show the background color
 131   RenderTaskPtr renderTask = mRenderTaskList->CreateTask( mRootLayer.Get(), mDefaultCamera.Get() );
 132   renderTask->SetClearEnabled(true);
 133
 134   SurfaceResized( size.width, size.height );
 135
 136   // Create scene graph object
 137   mSceneObject = new SceneGraph::Scene();
 138   OwnerPointer< SceneGraph::Scene > transferOwnership( const_cast< SceneGraph::Scene* >( mSceneObject ) );
 139   AddSceneMessage( updateManager, transferOwnership );
 140 }
 141
 142 void Scene::Add(Actor& actor)
 143 {
 144   mRootLayer->Add( actor );
 145 }
 146
 147 void Scene::Remove(Actor& actor)
 148 {
 149   mRootLayer->Remove( actor );
 150 }
 151
 152 Size Scene::GetSize() const
 153 {
 154   return mSize;
 155 }
 156
 157 void Scene::SetDpi(Vector2 dpi)
 158 {
 159   mDpi = dpi;
 160 }
 161
 162 Vector2 Scene::GetDpi() const
 163 {
 164   return mDpi;
 165 }
 166
 167 RenderTaskList& Scene::GetRenderTaskList() const
 168 {
 169   return *mRenderTaskList;
 170 }
 171
 172 Dali::Layer Scene::GetRootLayer() const
 173 {
 174   return Dali::Layer( mRootLayer.Get() );
 175 }
 176
 177 LayerList& Scene::GetLayerList() const
 178 {
 179   return *mLayerList;
 180 }
 181
 182 uint32_t Scene::GetLayerCount() const
 183 {
 184   return mLayerList->GetLayerCount();
 185 }
 186
 187 Dali::Layer Scene::GetLayer( uint32_t depth ) const
 188 {
 189   return Dali::Layer(mLayerList->GetLayer( depth ));
 190 }
 191
 192 CameraActor& Scene::GetDefaultCameraActor()
 193 {
 194   return *mDefaultCamera;
 195 }
 196
 197 Actor& Scene::GetDefaultRootActor()
 198 {
 199   return *mRootLayer;
 200 }
 201
 202 void Scene::SurfaceResized( float width, float height )
 203 {
 204   if( ( fabsf( mSize.width - width ) > Math::MACHINE_EPSILON_1 ) || ( fabsf( mSize.height - height ) > Math::MACHINE_EPSILON_1 ) )
 205   {
 206     Rect< int32_t > newSize( 0, 0, static_cast< int32_t >( width ), static_cast< int32_t >( height ) ); // truncated
 207
 208     mSize.width = width;
 209     mSize.height = height;
 210
 211     // Calculates the aspect ratio, near and far clipping planes, field of view and camera Z position.
 212     mDefaultCamera->SetPerspectiveProjection( mSize );
 213
 214     mRootLayer->SetSize( mSize.width, mSize.height );
 215
 216     ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 217     SceneGraph::UpdateManager& updateManager = tls->GetUpdateManager();
 218     SetDefaultSurfaceRectMessage( updateManager, newSize );
 219
 220     // set default render-task viewport parameters
 221     RenderTaskPtr defaultRenderTask = mRenderTaskList->GetTask( 0u );
 222     defaultRenderTask->SetViewport( newSize );
 223   }
 224 }
 225
 226 void Scene::SurfaceReplaced()
 227 {
 228   if ( mSceneObject )
 229   {
 230     ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 231     SurfaceReplacedMessage( tls->GetUpdateManager(), *mSceneObject );
 232   }
 233 }
 234
 235 void Scene::Discard()
 236 {
 237   if( ThreadLocalStorage::Created() )
 238   {
 239     ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 240     tls->RemoveScene( this );
 241   }
 242 }
 243
 244 void Scene::RequestRebuildDepthTree()
 245 {
 246   mDepthTreeDirty = true;
 247 }
 248
 249 void Scene::QueueEvent( const Integration::Event& event )
 250 {
 251   mEventProcessor.QueueEvent( event );
 252 }
 253
 254 void Scene::ProcessEvents()
 255 {
 256   mEventProcessor.ProcessEvents();
 257 }
 258
 259 void Scene::RebuildDepthTree()
 260 {
 261   // If the depth tree needs rebuilding, do it in this frame only.
 262   if( mDepthTreeDirty )
 263   {
 264     ActorPtr actor( mRootLayer.Get() );
 265     actor->RebuildDepthTree();
 266     mDepthTreeDirty = false;
 267   }
 268 }
 269
 270 void Scene::SetBackgroundColor( const Vector4& color )
 271 {
 272   mBackgroundColor = color;
 273
 274   mRenderTaskList->GetTask( 0u )->SetClearColor( color );
 275   mRenderTaskList->GetTask( 0u )->SetClearEnabled( true );
 276 }
 277
 278 Vector4 Scene::GetBackgroundColor() const
 279 {
 280   return mBackgroundColor;
 281 }
 282
 283 SceneGraph::Scene* Scene::GetSceneObject() const
 284 {
 285   return mSceneObject;
 286 }
 287
 288 void Scene::EmitKeyEventSignal(const Dali::KeyEvent& event)
 289 {
 290   if ( !mKeyEventSignal.Empty() )
 291   {
 292     Dali::Integration::Scene handle( this );
 293     mKeyEventSignal.Emit( event );
 294   }
 295 }
 296
 297 bool Scene::EmitKeyEventGeneratedSignal(const Dali::KeyEvent& event)
 298 {
 299   // Emit the KeyEventGenerated signal when KeyEvent is generated
 300   Dali::Integration::Scene handle( this );
 301   return mKeyEventGeneratedSignal.Emit( event );
 302 }
 303
 304 void Scene::EmitEventProcessingFinishedSignal()
 305 {
 306   if ( !mEventProcessingFinishedSignal.Empty() )
 307   {
 308     Dali::Integration::Scene handle( this );
 309     mEventProcessingFinishedSignal.Emit();
 310   }
 311 }
 312
 313 void Scene::EmitTouchedSignal( const Dali::TouchEvent& touch )
 314 {
 315   Dali::Integration::Scene handle( this );
 316   if ( !mTouchedSignal.Empty() )
 317   {
 318     mTouchedSignal.Emit( touch );
 319   }
 320 }
 321
 322 void Scene::EmitWheelEventSignal(const Dali::WheelEvent& event)
 323 {
 324   if ( !mWheelEventSignal.Empty() )
 325   {
 326     Dali::Integration::Scene handle( this );
 327     mWheelEventSignal.Emit( event );
 328   }
 329 }
 330
 331 void Scene::AddFrameRenderedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId )
 332 {
 333   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 334   AddFrameRenderedCallbackMessage( tls->GetEventThreadServices(), *mSceneObject, callback.release(), frameId );
 335 }
 336
 337 void Scene::AddFramePresentedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId )
 338 {
 339   ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
 340   AddFramePresentedCallbackMessage( tls->GetEventThreadServices(), *mSceneObject, callback.release(), frameId );
 341 }
 342
 343 void Scene::GetFrameRenderedCallback( Dali::Integration::Scene::FrameCallbackContainer& callbacks )
 344 {
 345   mSceneObject->GetFrameRenderedCallback( callbacks );
 346 }
 347
 348 void Scene::GetFramePresentedCallback( Dali::Integration::Scene::FrameCallbackContainer& callbacks )
 349 {
 350   mSceneObject->GetFramePresentedCallback( callbacks );
 351 }
 352
 353 Integration::Scene::KeyEventSignalType& Scene::KeyEventSignal()
 354 {
 355   return mKeyEventSignal;
 356 }
 357
 358 Integration::Scene::KeyEventGeneratedSignalType& Scene::KeyEventGeneratedSignal()
 359 {
 360   return mKeyEventGeneratedSignal;
 361 }
 362
 363 Integration::Scene::EventProcessingFinishedSignalType& Scene::EventProcessingFinishedSignal()
 364 {
 365   return mEventProcessingFinishedSignal;
 366 }
 367
 368 Integration::Scene::TouchEventSignalType& Scene::TouchedSignal()
 369 {
 370   return mTouchedSignal;
 371 }
 372
 373 Integration::Scene::WheelEventSignalType& Scene::WheelEventSignal()
 374 {
 375   return mWheelEventSignal;
 376 }
 377
 378 std::vector<Dali::Internal::SceneGraph::DirtyRect>& Scene::GetItemsDirtyRects()
 379 {
 380   return mItemsDirtyRects;
 381 }
 382
 383 } // Internal
 384
 385 } // Dali