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