adaptors/base/render-thread.h

   1 #ifndef __DALI_INTERNAL_RENDER_THREAD_H__
   2 #define __DALI_INTERNAL_RENDER_THREAD_H__
   3
   4 /*
   5  * Copyright (c) 2014 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 // EXTERNAL INCLUDES
  22 #include <boost/thread.hpp>
  23
  24 // INTERNAL INCLUDES
  25 #include <base/interfaces/egl-interface.h>
  26 #include <render-surface-impl.h> // needed for Dali::Internal::Adaptor::RenderSurface
  27
  28
  29 namespace Dali
  30 {
  31
  32 namespace Integration
  33 {
  34 class GlAbstraction;
  35 class Core;
  36 }
  37
  38 namespace Internal
  39 {
  40 namespace Adaptor
  41 {
  42
  43 class AdaptorInternalServices;
  44 class RenderSurface;
  45 class UpdateRenderSynchronization;
  46 class EglFactoryInterface;
  47 class EnvironmentOptions;
  48
  49
  50 class RenderRequest
  51 {
  52 public:
  53   enum Request
  54   {
  55     REPLACE_SURFACE, // Request to replace surface
  56   };
  57
  58   /**
  59    * Constructor.
  60    * @param[in] type The type of the request
  61    */
  62   RenderRequest( Request type );
  63
  64   /**
  65    * @return the type of the request
  66    */
  67   Request GetType();
  68
  69 private:
  70   Request mRequestType;
  71 };
  72
  73 class ReplaceSurfaceRequest : public RenderRequest
  74 {
  75 public:
  76
  77   /**
  78    * Constructor
  79    */
  80   ReplaceSurfaceRequest();
  81
  82   /**
  83    * Set the new surface
  84    * @param[in] newSurface The new surface to use
  85    */
  86   void SetSurface(RenderSurface* newSurface);
  87
  88   /**
  89    * @return the new surface
  90    */
  91   RenderSurface* GetSurface();
  92
  93   /**
  94    * Called when the request has been completed to set the result.
  95    */
  96   void ReplaceCompleted();
  97
  98   /**
  99    * @return true if the replace has completed.
 100    */
 101   bool GetReplaceCompleted();
 102
 103 private:
 104   RenderSurface* mNewSurface;     ///< The new surface to use.
 105   unsigned int mReplaceCompleted; ///< Set to true when the replace has completed.
 106 };
 107
 108
 109 /**
 110  * The render-thread is responsible for calling Core::Render() after each update.
 111  */
 112 class RenderThread
 113 {
 114 public:
 115
 116   /**
 117    * Create the render-thread; this will not do anything until Start() is called.
 118    * @param[in] sync update-render synchronization object
 119    * @param[in] adaptorInterfaces base adaptor interface
 120    * @param[in] environmentOptions environment options
 121
 122    */
 123   RenderThread( UpdateRenderSynchronization& sync,
 124                 AdaptorInternalServices& adaptorInterfaces,
 125                 const EnvironmentOptions& environmentOptions );
 126
 127   /**
 128    * Virtual Destructor
 129    */
 130   virtual ~RenderThread();
 131
 132 public:
 133
 134   /**
 135    * Starts the render-thread
 136    */
 137   void Start();
 138
 139   /**
 140    * Stops the render-thread
 141    */
 142   void Stop();
 143
 144   /**
 145    * Offscreen was posted to onscreen
 146    */
 147   void RenderSync();
 148
 149 private: // Render thread side helpers
 150
 151   /**
 152    * This method is used by the Render thread for rendering the Core to the screen.
 153    * Called from render thread
 154    * @return true, if the thread finishes properly.
 155    */
 156   bool Run();
 157
 158   /**
 159    * Initializes EGL.
 160    * Called from render thread
 161    */
 162   void InitializeEgl();
 163
 164   /**
 165    * Check if display has events
 166    * Called from render thread
 167    */
 168   void ConsumeEvents();
 169
 170   /**
 171    * Check if main thread made any requests, e.g. ReplaceSurface
 172    * Called from render thread
 173    * @return true if a request was processed, false otherwise.
 174    */
 175   bool ProcessRequest(RenderRequest* request);
 176
 177   /**
 178    * Replaces the rendering surface
 179    * Used for replacing pixmaps due to resizing
 180    * Called from render thread
 181    * @param newSurface to use
 182    */
 183   void ReplaceSurface( RenderSurface* newSurface );
 184
 185   /**
 186    * Shuts down EGL.
 187    * Called from render thread
 188    */
 189   void ShutdownEgl();
 190
 191   /**
 192    * Called before core renders the scene
 193    * Called from render thread
 194    * @return true if successful and Core::Render should be called.
 195    */
 196   bool PreRender();
 197
 198   /**
 199    * Called after core has rendered the scene
 200    * Called from render thread
 201    * @param[in] timeDelta Time since PostRender was last called in microseconds
 202    */
 203   void PostRender( unsigned int timeDelta );
 204
 205 private: // Data
 206
 207   UpdateRenderSynchronization&  mUpdateRenderSync;       ///< Used to synchronize the update & render threads
 208   Dali::Integration::Core&      mCore;                   ///< Dali core reference
 209   Integration::GlAbstraction&   mGLES;                   ///< GL abstraction reference
 210   EglFactoryInterface*          mEglFactory;             ///< Factory class to create EGL implementation
 211   EglInterface*                 mEGL;                    ///< Interface to EGL implementation
 212   boost::thread*                mThread;                 ///< render thread
 213   RenderSurface*                mSurface;                ///< Current surface
 214   const EnvironmentOptions&     mEnvironmentOptions;     ///< Environment options
 215   bool                          mSurfaceReplaced;        ///< True when new surface has been initialzed.
 216 };
 217
 218 } // namespace Adaptor
 219
 220 } // namespace Internal
 221
 222 } // namespace Dali
 223
 224 #endif // __DALI_INTERNAL_RENDER_THREAD_H__