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 <egl-interface.h>
  26 #include <render-surface.h> // needed for Dali::RenderSurface
  27
  28 namespace Dali
  29 {
  30
  31 class RenderSurface;
  32 class DisplayConnection;
  33
  34 namespace Integration
  35 {
  36 class GlAbstraction;
  37 class Core;
  38 }
  39
  40 namespace Internal
  41 {
  42 namespace Adaptor
  43 {
  44
  45 class AdaptorInternalServices;
  46 class UpdateRenderSynchronization;
  47 class EglFactoryInterface;
  48 class EnvironmentOptions;
  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   RenderThread( UpdateRenderSynchronization& sync,
 123                 AdaptorInternalServices& adaptorInterfaces,
 124                 const EnvironmentOptions& environmentOptions );
 125
 126   /**
 127    * Destructor
 128    */
 129   ~RenderThread();
 130
 131 public:
 132
 133   /**
 134    * Starts the render-thread
 135    */
 136   void Start();
 137
 138   /**
 139    * Stops the render-thread
 140    */
 141   void Stop();
 142
 143 private: // Render thread side helpers
 144
 145   /**
 146    * This method is used by the Render thread for rendering the Core to the screen.
 147    * Called from render thread
 148    * @return true, if the thread finishes properly.
 149    */
 150   bool Run();
 151
 152   /**
 153    * Initializes EGL.
 154    * Called from render thread
 155    */
 156   void InitializeEgl();
 157
 158   /**
 159    * Check if main thread made any requests, e.g. ReplaceSurface
 160    * Called from render thread
 161    * @return true if a request was processed, false otherwise.
 162    */
 163   bool ProcessRequest(RenderRequest* request);
 164
 165   /**
 166    * Replaces the rendering surface
 167    * Used for replacing pixmaps due to resizing
 168    * Called from render thread
 169    * @param newSurface to use
 170    */
 171   void ReplaceSurface( RenderSurface* newSurface );
 172
 173   /**
 174    * Shuts down EGL.
 175    * Called from render thread
 176    */
 177   void ShutdownEgl();
 178
 179   /**
 180    * Called before core renders the scene
 181    * Called from render thread
 182    * @return true if successful and Core::Render should be called.
 183    */
 184   bool PreRender();
 185
 186   /**
 187    * Called after core has rendered the scene
 188    * Called from render thread
 189    * @param[in] timeDelta Time since PostRender was last called in microseconds
 190    */
 191   void PostRender( unsigned int timeDelta );
 192
 193 private: // Data
 194
 195   UpdateRenderSynchronization&  mUpdateRenderSync;       ///< Used to synchronize the update & render threads
 196   Dali::Integration::Core&      mCore;                   ///< Dali core reference
 197   Integration::GlAbstraction&   mGLES;                   ///< GL abstraction reference
 198   EglFactoryInterface*          mEglFactory;             ///< Factory class to create EGL implementation
 199   EglInterface*                 mEGL;                    ///< Interface to EGL implementation
 200   boost::thread*                mThread;                 ///< render thread
 201   RenderSurface*                mSurface;                ///< Current surface
 202   Dali::DisplayConnection*      mDisplayConnection;      ///< Display connection
 203   const EnvironmentOptions&     mEnvironmentOptions;     ///< Environment options
 204   bool                          mSurfaceReplaced;        ///< True when new surface has been initialzed.
 205 };
 206
 207 } // namespace Adaptor
 208
 209 } // namespace Internal
 210
 211 } // namespace Dali
 212
 213 #endif // __DALI_INTERNAL_RENDER_THREAD_H__