dali/internal/common/core-impl.h

   1 #ifndef DALI_INTERNAL_CORE_H
   2 #define DALI_INTERNAL_CORE_H
   3
   4 /*
   5  * Copyright (c) 2019 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/common/dali-vector.h>
  23 #include <dali/public-api/object/ref-object.h>
  24 #include <dali/integration-api/context-notifier.h>
  25 #include <dali/integration-api/core-enumerations.h>
  26 #include <dali/internal/common/owner-pointer.h>
  27 #include <dali/devel-api/common/owner-container.h>
  28 #include <dali/internal/event/animation/animation-playlist-declarations.h>
  29 #include <dali/internal/event/common/stage-def.h>
  30 #include <dali/integration-api/resource-policies.h>
  31 #include <dali/internal/event/common/scene-impl.h>
  32 #include <dali/internal/event/common/object-registry-impl.h>
  33
  34 namespace Dali
  35 {
  36
  37 namespace Integration
  38 {
  39 class Processor;
  40 class RenderController;
  41 class PlatformAbstraction;
  42 class GlAbstraction;
  43 class GlSyncAbstraction;
  44 class UpdateStatus;
  45 class RenderStatus;
  46 class RenderSurface;
  47 struct Event;
  48 struct TouchData;
  49 }
  50
  51 namespace Internal
  52 {
  53
  54 class NotificationManager;
  55 class AnimationPlaylist;
  56 class PropertyNotificationManager;
  57 class EventProcessor;
  58 class GestureEventProcessor;
  59 class ShaderFactory;
  60 class TouchResampler;
  61 class RelayoutController;
  62 class EventThreadServices;
  63
  64 namespace SceneGraph
  65 {
  66 class UpdateManager;
  67 class RenderManager;
  68 class DiscardQueue;
  69 class RenderTaskProcessor;
  70 }
  71
  72 /**
  73  * Internal class for Dali::Integration::Core
  74  */
  75 class Core : public EventThreadServices
  76 {
  77 public:
  78
  79   /**
  80    * Create and initialise a new Core instance
  81    */
  82   Core( Integration::RenderController& renderController,
  83         Integration::PlatformAbstraction& platform,
  84         Integration::GlAbstraction& glAbstraction,
  85         Integration::GlSyncAbstraction& glSyncAbstraction,
  86         ResourcePolicy::DataRetention dataRetentionPolicy,
  87         Integration::RenderToFrameBuffer renderToFboEnabled,
  88         Integration::DepthBufferAvailable depthBufferAvailable,
  89         Integration::StencilBufferAvailable stencilBufferAvailable );
  90
  91   /**
  92    * Destructor
  93    */
  94   ~Core();
  95
  96   /**
  97    * @copydoc Dali::Integration::Core::Initialize()
  98    */
  99   void Initialize();
 100
 101   /**
 102    * @copydoc Dali::Integration::Core::GetContextNotifier()
 103    */
 104   Integration::ContextNotifierInterface* GetContextNotifier();
 105
 106   /**
 107    * @copydoc Dali::Integration::Core::ContextCreated()
 108    */
 109   void ContextCreated();
 110
 111   /**
 112    * @copydoc Dali::Integration::Core::ContextDestroyed()
 113    */
 114   void ContextDestroyed();
 115
 116   /**
 117    * @copydoc Dali::Integration::Core::RecoverFromContextLoss()
 118    */
 119   void RecoverFromContextLoss();
 120
 121   /**
 122    * @copydoc Dali::Integration::Core::SurfaceResized(Integration::RenderSurface*)
 123    */
 124   void SurfaceResized( Integration::RenderSurface* surface );
 125
 126   /**
 127    * @copydoc Dali::Integration::Core::SetMinimumFrameTimeInterval(uint32_t)
 128    */
 129   void SetMinimumFrameTimeInterval(uint32_t interval);
 130
 131   /**
 132    * @copydoc Dali::Integration::Core::Update()
 133    */
 134   void Update( float elapsedSeconds, uint32_t lastVSyncTimeMilliseconds, uint32_t nextVSyncTimeMilliseconds, Integration::UpdateStatus& status, bool renderToFboEnabled, bool isRenderingToFbo );
 135
 136   /**
 137    * @copydoc Dali::Integration::Core::Render()
 138    */
 139   void Render( Integration::RenderStatus& status, bool forceClear );
 140
 141   /**
 142    * @copydoc Dali::Integration::Core::SceneCreated()
 143    */
 144   void SceneCreated();
 145
 146   /**
 147    * @copydoc Dali::Integration::Core::QueueEvent(const Integration::Event&)
 148    */
 149   void QueueEvent( const Integration::Event& event );
 150
 151   /**
 152    * @copydoc Dali::Integration::Core::ProcessEvents()
 153    */
 154   void ProcessEvents();
 155
 156   /**
 157    * @copydoc Dali::Integration::Core::GetMaximumUpdateCount()
 158    */
 159   uint32_t GetMaximumUpdateCount() const;
 160
 161   /**
 162    * @copydoc Dali::Integration::Core::RegisterProcessor
 163    */
 164   void RegisterProcessor( Dali::Integration::Processor& processor );
 165
 166   /**
 167    * @copydoc Dali::Integration::Core::UnregisterProcessor
 168    */
 169   void UnregisterProcessor( Dali::Integration::Processor& processor );
 170
 171   /**
 172    * @copydoc Dali::Internal::ThreadLocalStorage::AddScene()
 173    */
 174   void AddScene( Scene* scene );
 175
 176   /**
 177    * @copydoc Dali::Internal::ThreadLocalStorage::RemoveScene()
 178    */
 179   void RemoveScene( Scene* scene );
 180
 181 public: // Implementation of EventThreadServices
 182
 183   /**
 184    * @copydoc EventThreadServices::RegisterObject
 185    */
 186   void RegisterObject( BaseObject* object) override;
 187
 188   /**
 189    * @copydoc EventThreadServices::UnregisterObject
 190    */
 191   void UnregisterObject( BaseObject* object) override;
 192
 193   /**
 194    * @copydoc EventThreadServices::GetUpdateManager
 195    */
 196   SceneGraph::UpdateManager& GetUpdateManager() override;
 197
 198   /**
 199    * @copydoc EventThreadServices::GetRenderController
 200    */
 201   Integration::RenderController& GetRenderController() override;
 202
 203   /**
 204    * @copydoc EventThreadServices::ReserveMessageSlot
 205    */
 206   uint32_t* ReserveMessageSlot( uint32_t size, bool updateScene ) override;
 207
 208   /**
 209    * @copydoc EventThreadServices::GetEventBufferIndex
 210    */
 211   BufferIndex GetEventBufferIndex() const override;
 212
 213   /**
 214    * @copydoc EventThreadServices::ForceNextUpdate
 215    */
 216   void ForceNextUpdate() override;
 217
 218   /**
 219    * @copydoc EventThreadServices::IsNextUpdateForced
 220    */
 221   bool IsNextUpdateForced() override;
 222
 223 private:
 224   /**
 225    * Run each registered processor
 226    */
 227   void RunProcessors();
 228
 229   // for use by ThreadLocalStorage
 230
 231   /**
 232    * Returns the current stage.
 233    * @return A smart-pointer to the current stage.
 234    */
 235   StagePtr GetCurrentStage();
 236
 237   /**
 238    * Returns the platform abstraction.
 239    * @return A reference to the platform abstraction.
 240    */
 241   Integration::PlatformAbstraction& GetPlatform();
 242
 243   /**
 244    * Returns the render manager.
 245    * @return A reference to the render manager.
 246    */
 247   SceneGraph::RenderManager& GetRenderManager();
 248
 249   /**
 250    * Returns the notification manager.
 251    * @return A reference to the Notification Manager.
 252    */
 253   NotificationManager& GetNotificationManager();
 254
 255   /**
 256    * Returns the Shader factory
 257    * @return A reference to the Shader binary factory.
 258    */
 259   ShaderFactory& GetShaderFactory();
 260
 261   /**
 262    * Returns the gesture event processor.
 263    * @return A reference to the gesture event processor.
 264    */
 265   GestureEventProcessor& GetGestureEventProcessor();
 266
 267   /**
 268    * Return the relayout controller
 269    * @Return Return a reference to the relayout controller
 270    */
 271   RelayoutController& GetRelayoutController();
 272
 273   /**
 274    * @brief Gets the Object registry.
 275    * @return A reference to the object registry
 276    */
 277   ObjectRegistry& GetObjectRegistry() const;
 278
 279   /**
 280    * @brief Gets the event thread services.
 281    * @return A reference to the event thread services
 282    */
 283   EventThreadServices& GetEventThreadServices();
 284
 285   /**
 286    * @brief Gets the property notification manager.
 287    * @return A reference to the property notification manager
 288    */
 289   PropertyNotificationManager& GetPropertyNotificationManager() const;
 290
 291   /**
 292    * @brief Gets the animation play list.
 293    * @return A reference to the animation play list
 294    */
 295   AnimationPlaylist& GetAnimationPlaylist() const;
 296
 297 private:
 298
 299   /**
 300    * Undefined copy and assignment operators
 301    */
 302   Core(const Core& core) = delete;  // No definition
 303   Core& operator=(const Core& core) = delete;  // No definition
 304
 305   /**
 306    * Create Thread local storage
 307    */
 308   void CreateThreadLocalStorage();
 309
 310 private:
 311
 312   Integration::RenderController&            mRenderController;            ///< Reference to Render controller to tell it to keep rendering
 313   Integration::PlatformAbstraction&         mPlatform;                    ///< The interface providing platform specific services.
 314
 315   IntrusivePtr<Stage>                       mStage;                       ///< The current stage
 316   AnimationPlaylistOwner                    mAnimationPlaylist;           ///< For 'Fire and forget' animation support
 317   OwnerPointer<PropertyNotificationManager> mPropertyNotificationManager; ///< For safe signal emmision of property changed notifications
 318   IntrusivePtr< RelayoutController >        mRelayoutController;          ///< Size negotiation relayout controller
 319
 320   OwnerPointer<SceneGraph::RenderTaskProcessor> mRenderTaskProcessor;         ///< Handles the processing of render tasks
 321   OwnerPointer<SceneGraph::RenderManager>       mRenderManager;               ///< Render manager
 322   OwnerPointer<SceneGraph::UpdateManager>       mUpdateManager;               ///< Update manager
 323   OwnerPointer<SceneGraph::DiscardQueue>        mDiscardQueue;                ///< Used to cleanup nodes & resources when no longer in use.
 324   OwnerPointer<ShaderFactory>                   mShaderFactory;               ///< Shader resource factory
 325   OwnerPointer<NotificationManager>             mNotificationManager;         ///< Notification manager
 326   OwnerPointer<GestureEventProcessor>           mGestureEventProcessor;       ///< The gesture event processor
 327   Dali::Vector<Integration::Processor*>         mProcessors;                  ///< Registered processors (not owned)
 328
 329   using SceneContainer = std::vector<ScenePtr>;
 330   SceneContainer                                mScenes;                      ///< A container of scenes that bound to a surface for rendering, owned by Core
 331
 332   // The object registry
 333   ObjectRegistryPtr                             mObjectRegistry;
 334
 335   bool                                      mProcessingEvent  : 1;        ///< True during ProcessEvents()
 336   bool                                      mForceNextUpdate:1;           ///< True if the next rendering is really required.
 337
 338   friend class ThreadLocalStorage;
 339
 340 };
 341
 342 } // namespace Internal
 343
 344 } // namespace Dali
 345
 346 #endif // DALI_INTERNAL_CORE_H