(Scene) Add frame rendered/presented callback

Change-Id: Ic903229e71d76a05a0af24a68b26440d26462fa6

diff --git a/automated-tests/src/dali/utc-Dali-Scene.cpp b/automated-tests/src/dali/utc-Dali-Scene.cpp
index b52e2c2ddcff37686312645e0fb594c5d0236274..3399686565e2708ac33c0141d1c105aae46b47d7 100644 (file)
--- a/automated-tests/src/dali/utc-Dali-Scene.cpp
+++ b/automated-tests/src/dali/utc-Dali-Scene.cpp
@@ -248,6 +248,10 @@ bool DummyTouchCallback( Actor actor, const TouchEvent& touch )
   return true;
 }
 
+void FrameCallback( int frameId )
+{
+}
+
 } // unnamed namespace
 
 int UtcDaliSceneAdd(void)
@@ -1215,3 +1219,44 @@ int UtcDaliSceneEmptySceneRendering(void)
 
   END_TEST;
 }
+
+int UtcDaliSceneFrameRenderedPresentedCallback(void)
+{
+  tet_infoline( "UtcDaliSceneFrameRenderedCallback" );
+
+  TestApplication application;
+
+  // Add a Renderer
+  Geometry geometry = CreateQuadGeometry();
+  Shader shader = CreateShader();
+  Renderer renderer = Renderer::New( geometry, shader );
+
+  Actor actor = Actor::New();
+  actor.AddRenderer( renderer );
+  Stage::GetCurrent().Add( actor );
+
+  Dali::Integration::Scene scene = application.GetScene();
+
+  int frameId = 1;
+  scene.AddFrameRenderedCallback( std::unique_ptr< CallbackBase >( MakeCallback( &FrameCallback ) ), frameId );
+  scene.AddFramePresentedCallback( std::unique_ptr< CallbackBase >( MakeCallback( &FrameCallback ) ), frameId );
+
+  // Render
+  application.SendNotification();
+  application.Render();
+
+  Dali::Integration::Scene::FrameCallbackContainer callbackContainer;
+  scene.GetFrameRenderedCallback( callbackContainer );
+
+  DALI_TEST_EQUALS( callbackContainer.size(), 1, TEST_LOCATION );
+  DALI_TEST_EQUALS( callbackContainer[0].second, frameId, TEST_LOCATION );
+
+  callbackContainer.clear();
+
+  scene.GetFramePresentedCallback( callbackContainer );
+
+  DALI_TEST_EQUALS( callbackContainer.size(), 1, TEST_LOCATION );
+  DALI_TEST_EQUALS( callbackContainer[0].second, frameId, TEST_LOCATION );
+
+  END_TEST;
+}

diff --git a/dali/integration-api/scene.cpp b/dali/integration-api/scene.cpp
index c8bc91b6f9887154daa67255845805ed1f1fa120..4ab7dbfa400f0701927ba6dd1f6c2df3410f2c9c 100644 (file)
--- a/dali/integration-api/scene.cpp
+++ b/dali/integration-api/scene.cpp
@@ -149,6 +149,26 @@ void Scene::ProcessEvents()
   GetImplementation(*this).ProcessEvents();
 }
 
+void Scene::AddFrameRenderedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId )
+{
+  GetImplementation( *this ).AddFrameRenderedCallback( std::move( callback ), frameId );
+}
+
+void Scene::AddFramePresentedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId )
+{
+  GetImplementation( *this ).AddFramePresentedCallback( std::move( callback ), frameId );
+}
+
+void Scene::GetFrameRenderedCallback( FrameCallbackContainer& callbacks )
+{
+  GetImplementation( *this ).GetFrameRenderedCallback( callbacks );
+}
+
+void Scene::GetFramePresentedCallback( FrameCallbackContainer& callbacks )
+{
+  GetImplementation( *this ).GetFramePresentedCallback( callbacks );
+}
+
 Scene::EventProcessingFinishedSignalType& Scene::EventProcessingFinishedSignal()
 {
   return GetImplementation(*this).EventProcessingFinishedSignal();

diff --git a/dali/integration-api/scene.h b/dali/integration-api/scene.h
index 9211ae18ad5d860099a5e0673f1bae3b6f2c1c3f..7d54eb91815eb92cc909b4965252ee9b5883e505 100755 (executable)
--- a/dali/integration-api/scene.h
+++ b/dali/integration-api/scene.h
@@ -18,10 +18,14 @@
  *
  */
 
+// EXTERNAL INCLUDES
+#include <memory>
+
 // INTERNAL INCLUDES
 #include <dali/public-api/object/handle.h>
 #include <dali/public-api/math/vector2.h>
 #include <dali/public-api/math/vector4.h>
+#include <dali/public-api/common/vector-wrapper.h>
 
 namespace Dali
 {
@@ -58,6 +62,8 @@ public:
   typedef Signal< void (const Dali::TouchData&) > TouchSignalType; ///< Touch signal type
   typedef Signal< void (const Dali::WheelEvent&) > WheelEventSignalType; ///< Touched signal type
 
+  using FrameCallbackContainer = std::vector< std::pair< std::unique_ptr< CallbackBase >, int32_t > >;
+
   /**
    * @brief Create an initialized Scene handle.
    *
@@ -229,6 +235,56 @@ public:
    */
   void ProcessEvents();
 
+  /**
+   * @brief Adds a callback that is called when the frame rendering is done by the graphics driver.
+   *
+   * @param[in] callback The function to call
+   * @param[in] frameId The Id to specify the frame. It will be passed when the callback is called.
+   *
+   * @note A callback of the following type may be used:
+   * @code
+   *   void MyFunction( int frameId );
+   * @endcode
+   * This callback will be deleted once it is called.
+   *
+   * @note Ownership of the callback is passed onto this class.
+   */
+  void AddFrameRenderedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId );
+
+  /**
+   * @brief Adds a callback that is called when the frame is displayed on the display.
+   *
+   * @param[in] callback The function to call
+   * @param[in] frameId The Id to specify the frame. It will be passed when the callback is called.
+   *
+   * @note A callback of the following type may be used:
+   * @code
+   *   void MyFunction( int frameId );
+   * @endcode
+   * This callback will be deleted once it is called.
+   *
+   * @note Ownership of the callback is passed onto this class.
+   */
+  void AddFramePresentedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId );
+
+  /**
+   * @brief Gets the callback list that is called when the frame rendering is done by the graphics driver.
+   *
+   * @param[out] callbacks The callback list
+   *
+   * @note This is called in the update thread.
+   */
+  void GetFrameRenderedCallback( FrameCallbackContainer& callbacks );
+
+  /**
+   * @brief Gets the callback list that is called when the frame is displayed on the display.
+   *
+   * @param[out] callbacks The callback list
+   *
+   * @note This is called in the update thread.
+   */
+  void GetFramePresentedCallback( FrameCallbackContainer& callbacks );
+
   /**
    * @brief This signal is emitted just after the event processing is finished.
    *

diff --git a/dali/internal/event/common/scene-impl.cpp b/dali/internal/event/common/scene-impl.cpp
index d7b80d647a08dc6e6f5310447cf19742cac7ef43..acb362d92b1bd3cfd16417c7e890a472940d733b 100644 (file)
--- a/dali/internal/event/common/scene-impl.cpp
+++ b/dali/internal/event/common/scene-impl.cpp
@@ -337,6 +337,28 @@ void Scene::EmitWheelEventSignal(const WheelEvent& event)
   }
 }
 
+void Scene::AddFrameRenderedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId )
+{
+  ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
+  AddFrameRenderedCallbackMessage( tls->GetEventThreadServices(), *mSceneObject, callback.release(), frameId );
+}
+
+void Scene::AddFramePresentedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId )
+{
+  ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
+  AddFramePresentedCallbackMessage( tls->GetEventThreadServices(), *mSceneObject, callback.release(), frameId );
+}
+
+void Scene::GetFrameRenderedCallback( Dali::Integration::Scene::FrameCallbackContainer& callbacks )
+{
+  mSceneObject->GetFrameRenderedCallback( callbacks );
+}
+
+void Scene::GetFramePresentedCallback( Dali::Integration::Scene::FrameCallbackContainer& callbacks )
+{
+  mSceneObject->GetFramePresentedCallback( callbacks );
+}
+
 Integration::Scene::KeyEventSignalType& Scene::KeyEventSignal()
 {
   return mKeyEventSignal;

diff --git a/dali/internal/event/common/scene-impl.h b/dali/internal/event/common/scene-impl.h
index 99a3e507cdd952423f3508ff30a94feb43b68aae..fbf22b22ec72830580e9858b5bce7f29bfd3c532 100644 (file)
--- a/dali/internal/event/common/scene-impl.h
+++ b/dali/internal/event/common/scene-impl.h
@@ -216,6 +216,26 @@ public:
    */
   void EmitWheelEventSignal( const WheelEvent& event );
 
+  /**
+   * @copydoc Dali::Integration::Scene::AddFrameRenderedCallback
+   */
+  void AddFrameRenderedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId );
+
+  /**
+   * @copydoc Dali::Integration::Scene::AddFramePresentedCallback
+   */
+  void AddFramePresentedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId );
+
+  /**
+   * @copydoc Dali::Integration::Scene::GetFrameRenderedCallback
+   */
+  void GetFrameRenderedCallback( Dali::Integration::Scene::FrameCallbackContainer& callbacks );
+
+  /**
+   * @copydoc Dali::Integration::Scene::GetFramePresentedCallback
+   */
+  void GetFramePresentedCallback( Dali::Integration::Scene::FrameCallbackContainer& callbacks );
+
   /**
    * @copydoc Integration::Scene::KeyEventSignal()
    */

diff --git a/dali/internal/update/common/scene-graph-scene.cpp b/dali/internal/update/common/scene-graph-scene.cpp
index 0540516b1ade2a5a2a1635e4a93f660842e71183..7f9bf311311087d15daba7aabaab283c736b88de 100644 (file)
--- a/dali/internal/update/common/scene-graph-scene.cpp
+++ b/dali/internal/update/common/scene-graph-scene.cpp
@@ -27,7 +27,9 @@ namespace SceneGraph
 {
 
 Scene::Scene()
-: mContext( nullptr )
+: mContext( nullptr ),
+  mFrameRenderedCallbacks(),
+  mFramePresentedCallbacks()
 {
 }
 
@@ -40,6 +42,9 @@ Scene::~Scene()
     delete mContext;
     mContext = nullptr;
   }
+
+  mFrameRenderedCallbacks.clear();
+  mFramePresentedCallbacks.clear();
 }
 
 void Scene::GlContextDestroyed()
@@ -75,6 +80,38 @@ RenderInstructionContainer& Scene::GetRenderInstructions()
   return mInstructions;
 }
 
+void Scene::AddFrameRenderedCallback( CallbackBase* callback, int32_t frameId )
+{
+  mFrameRenderedCallbacks.push_back( std::make_pair( std::unique_ptr< CallbackBase >( callback ), frameId ) );
+}
+
+void Scene::AddFramePresentedCallback( CallbackBase* callback, int32_t frameId )
+{
+  mFramePresentedCallbacks.push_back( std::make_pair( std::unique_ptr< CallbackBase >( callback ), frameId ) );
+}
+
+void Scene::GetFrameRenderedCallback( Dali::Integration::Scene::FrameCallbackContainer& callbacks )
+{
+  // Transfer owership of the callbacks
+  for( auto&& iter : mFrameRenderedCallbacks )
+  {
+    callbacks.push_back( std::make_pair( std::move( iter.first ), iter.second ) );
+  }
+
+  mFrameRenderedCallbacks.clear();
+}
+
+void Scene::GetFramePresentedCallback( Dali::Integration::Scene::FrameCallbackContainer& callbacks )
+{
+  // Transfer owership of the callbacks
+  for( auto&& iter : mFramePresentedCallbacks )
+  {
+    callbacks.push_back( std::make_pair( std::move( iter.first ), iter.second ) );
+  }
+
+  mFramePresentedCallbacks.clear();
+}
+
 } //SceneGraph
 
 } //Internal

diff --git a/dali/internal/update/common/scene-graph-scene.h b/dali/internal/update/common/scene-graph-scene.h
index 221c42ef1e6dc80d900dd5481578104d4dc9a0e2..a94becca3b22c9e1b18d2fefab2f84addc55b959 100644 (file)
--- a/dali/internal/update/common/scene-graph-scene.h
+++ b/dali/internal/update/common/scene-graph-scene.h
@@ -20,8 +20,11 @@
 // INTERNAL INCLUDES
 #include <dali/integration-api/scene.h>
 #include <dali/integration-api/gl-defines.h>
+#include <dali/internal/common/message.h>
+#include <dali/internal/event/common/event-thread-services.h>
 #include <dali/internal/render/gl-resources/context.h>
 #include <dali/internal/render/common/render-instruction-container.h>
+#include <dali/public-api/common/vector-wrapper.h>
 
 namespace Dali
 {
@@ -73,6 +76,52 @@ public:
    */
   RenderInstructionContainer& GetRenderInstructions();
 
+  /**
+   * @brief Adds a callback that is called when the frame rendering is done by the graphics driver.
+   *
+   * @param[in] callback The function to call
+   * @param[in] frameId The Id to specify the frame. It will be passed when the callback is called.
+   *
+   * @note A callback of the following type may be used:
+   * @code
+   *   void MyFunction( int frameId );
+   * @endcode
+   * This callback will be deleted once it is called.
+   *
+   * @note Ownership of the callback is passed onto this class.
+   */
+  void AddFrameRenderedCallback( CallbackBase* callback, int32_t frameId );
+
+  /**
+   * @brief Adds a callback that is called when the frame is displayed on the display.
+   *
+   * @param[in] callback The function to call
+   * @param[in] frameId The Id to specify the frame. It will be passed when the callback is called.
+   *
+   * @note A callback of the following type may be used:
+   * @code
+   *   void MyFunction( int frameId );
+   * @endcode
+   * This callback will be deleted once it is called.
+   *
+   * @note Ownership of the callback is passed onto this class.
+   */
+  void AddFramePresentedCallback( CallbackBase* callback, int32_t frameId );
+
+  /**
+   * @brief Gets the callback list that is called when the frame rendering is done by the graphics driver.
+   *
+   * @param[out] callbacks The callback list
+   */
+  void GetFrameRenderedCallback( Dali::Integration::Scene::FrameCallbackContainer& callbacks );
+
+  /**
+   * @brief Gets the callback list that is called when the frame is displayed on the display.
+   *
+   * @param[out] callbacks The callback list
+   */
+  void GetFramePresentedCallback( Dali::Integration::Scene::FrameCallbackContainer& callbacks );
+
 private:
 
   Context*                    mContext;   ///< The context holding the GL state of rendering for the scene
@@ -81,8 +130,33 @@ private:
   // Update manager updates instructions for the next frame while we render the current one
 
   RenderInstructionContainer  mInstructions;   ///< Render instructions for the scene
+
+  Dali::Integration::Scene::FrameCallbackContainer mFrameRenderedCallbacks;   ///< Frame rendered callbacks
+  Dali::Integration::Scene::FrameCallbackContainer mFramePresentedCallbacks;  ///< Frame presented callbacks
 };
 
+/// Messages
+inline void AddFrameRenderedCallbackMessage( EventThreadServices& eventThreadServices, const Scene& scene, const CallbackBase* callback, int32_t frameId )
+{
+  typedef MessageValue2< Scene, CallbackBase*, int32_t > LocalType;
+
+  // Reserve some memory inside the message queue
+  uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
+
+  // Construct message in the message queue memory; note that delete should not be called on the return value
+  new (slot) LocalType( &scene, &Scene::AddFrameRenderedCallback, const_cast< CallbackBase* >( callback ), frameId );
+}
+
+inline void AddFramePresentedCallbackMessage( EventThreadServices& eventThreadServices, const Scene& scene, const CallbackBase* callback, int32_t frameId )
+{
+  typedef MessageValue2< Scene, CallbackBase*, int32_t > LocalType;
+
+  // Reserve some memory inside the message queue
+  uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
+
+  // Construct message in the message queue memory; note that delete should not be called on the return value
+  new (slot) LocalType( &scene, &Scene::AddFramePresentedCallback, const_cast< CallbackBase* >( callback ), frameId );
+}
 
 } // namespace SceneGraph