Pan Gesture Prediction - Added DALI_PAN_GESTURE_PREDICTION_AMOUNT environment variable

Increase how far pan gestures try to predict position 1.0f is 1 frame further ahead. Can use decimals like 0.6 or 1.3.

Change-Id: Id5ac2e6c7273e25f51d41aa16ad113ec6632256d
Signed-off-by: Julien Heanley <j.heanley@partner.samsung.com>

diff --git a/dali/integration-api/profiling.cpp b/dali/integration-api/profiling.cpp
index c8199b3..66b87b8 100644 (file)
--- a/dali/integration-api/profiling.cpp
+++ b/dali/integration-api/profiling.cpp
@@ -110,6 +110,12 @@ void SetPanGesturePredictionMode( int mode )
   eventProcessor.SetPanGesturePredictionMode(mode);
 }
 
+void SetPanGesturePredictionAmount(float amount)
+{
+  GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
+  eventProcessor.SetPanGesturePredictionAmount(amount);
+}
+
 namespace Profiling
 {
 

diff --git a/dali/integration-api/profiling.h b/dali/integration-api/profiling.h
index 9a35141..d2ca414 100644 (file)
--- a/dali/integration-api/profiling.h
+++ b/dali/integration-api/profiling.h
@@ -52,6 +52,13 @@ DALI_IMPORT_API void EnableProfiling( ProfilingType type );
  */
 DALI_IMPORT_API void SetPanGesturePredictionMode( int mode );
 
+/**
+ * @brief Called by adaptor to set the prediction amount of the pan gesture from an environment variable
+ *
+ * @param[in] amount The prediction amount, 0.0f being next vsync and each 1.0f on top is another vsync ahead, can be divisions of (0.5f)
+ */
+DALI_IMPORT_API void SetPanGesturePredictionAmount(float amount);
+
 
 namespace Profiling
 {

diff --git a/dali/internal/event/events/gesture-event-processor.cpp b/dali/internal/event/events/gesture-event-processor.cpp
index 4b1f4c5..ec19849 100644 (file)
--- a/dali/internal/event/events/gesture-event-processor.cpp
+++ b/dali/internal/event/events/gesture-event-processor.cpp
@@ -234,6 +234,11 @@ void GestureEventProcessor::SetPanGesturePredictionMode(int mode)
   mPanGestureProcessor.SetPredictionMode(mode);
 }
 
+void GestureEventProcessor::SetPanGesturePredictionAmount( float amount )
+{
+  mPanGestureProcessor.SetPredictionAmount(amount);
+}
+
 } // namespace Internal
 
 } // namespace Dali

diff --git a/dali/internal/event/events/gesture-event-processor.h b/dali/internal/event/events/gesture-event-processor.h
index 4b944cb..27c5837 100644 (file)
--- a/dali/internal/event/events/gesture-event-processor.h
+++ b/dali/internal/event/events/gesture-event-processor.h
@@ -128,6 +128,13 @@ public: // Called by Core
    */
   void SetPanGesturePredictionMode( int mode );
 
+  /**
+   * @brief Sets the prediction amount of the pan gesture
+   *
+   * @param[in] amount The prediction amount, 0.0f being next vsync and each 1.0f on top is another vsync ahead, can be divisions of (0.5f)
+   */
+  void SetPanGesturePredictionAmount( float amount );
+
 private:
 
   // Undefined

diff --git a/dali/internal/event/events/pan-gesture-processor.cpp b/dali/internal/event/events/pan-gesture-processor.cpp
index 0d76ea9..dd8e6d5 100644 (file)
--- a/dali/internal/event/events/pan-gesture-processor.cpp
+++ b/dali/internal/event/events/pan-gesture-processor.cpp
@@ -434,6 +434,11 @@ void PanGestureProcessor::SetPredictionMode(int mode)
   mSceneObject->SetPredictionMode(modeEnum);
 }
 
+void PanGestureProcessor::SetPredictionAmount(float amount)
+{
+  mSceneObject->SetPredictionAmount(amount);
+}
+
 void PanGestureProcessor::UpdateDetection()
 {
   DALI_ASSERT_DEBUG(!mGestureDetectors.empty());

diff --git a/dali/internal/event/events/pan-gesture-processor.h b/dali/internal/event/events/pan-gesture-processor.h
index a75362d..efc30ff 100644 (file)
--- a/dali/internal/event/events/pan-gesture-processor.h
+++ b/dali/internal/event/events/pan-gesture-processor.h
@@ -125,6 +125,13 @@ public: // To be called by GestureEventProcessor
    */
   void SetPredictionMode(int mode);
 
+  /**
+   * @brief Sets the prediction amount of the pan gesture
+   *
+   * @param[in] amount The prediction amount, 0.0f being next vsync and each 1.0f on top is another vsync ahead, can be divisions of (0.5f)
+   */
+  void SetPredictionAmount(float amount);
+
 private:
 
   // Undefined

diff --git a/dali/internal/update/gestures/scene-graph-pan-gesture.cpp b/dali/internal/update/gestures/scene-graph-pan-gesture.cpp
index 4b0313f..b3340aa 100644 (file)
--- a/dali/internal/update/gestures/scene-graph-pan-gesture.cpp
+++ b/dali/internal/update/gestures/scene-graph-pan-gesture.cpp
@@ -33,9 +33,10 @@ namespace SceneGraph
 namespace
 {
 const int MAX_GESTURE_AGE = 50; ///< maximum age of a gesture before disallowing its use in algorithm
+const float DEFAULT_PREDICTION_INTERPOLATION = 0.0f; ///< how much to interpolate pan position and displacement from last vsync time
 } // unnamed namespace
 
-const PanGesture::PredictionMode PanGesture::DEFAULT_PREDICTION_MODE = PanGesture::AVERAGE;
+const PanGesture::PredictionMode PanGesture::DEFAULT_PREDICTION_MODE = PanGesture::PREDICTION_2;
 const int PanGesture::NUM_PREDICTION_MODES = PanGesture::PREDICTION_2 + 1;
 
 PanGesture* PanGesture::New()
@@ -229,13 +230,14 @@ void PanGesture::PredictiveAlgorithm2(int eventsThisFrame, PanInfo& gestureOut,
   }
   // gestureOut's position is currently equal to the last event's position and its displacement is equal to last frame's total displacement
   // add interpolated distance and position to current
-  float interpolationTime = (float)((int)lastVSyncTime - (int)gestureOut.time);
+  unsigned int timeAdvance = ((nextVSyncTime - lastVSyncTime) * mPredictionAmount);
+  unsigned int interpolationTime = (lastVSyncTime + timeAdvance) - gestureOut.time;
   // work out interpolated velocity
   gestureOut.screen.displacement = (gestureOut.screen.velocity * interpolationTime);
   gestureOut.local.displacement = (gestureOut.local.velocity * interpolationTime);
   gestureOut.screen.position += gestureOut.screen.displacement;
   gestureOut.local.position += gestureOut.local.displacement;
-  gestureOut.time += (lastVSyncTime - gestureOut.time);
+  gestureOut.time += interpolationTime;
 }
 
 bool PanGesture::UpdateProperties( unsigned int lastVSyncTime, unsigned int nextVSyncTime )
@@ -405,6 +407,16 @@ const GesturePropertyVector2& PanGesture::GetLocalDisplacementProperty() const
   return mLocalDisplacement;
 }
 
+void PanGesture::SetPredictionMode(PredictionMode mode)
+{
+  mPredictionMode = mode;
+}
+
+void PanGesture::SetPredictionAmount(float amount)
+{
+  mPredictionAmount = amount;
+}
+
 void PanGesture::EnableProfiling()
 {
   if( !mProfiling )
@@ -428,6 +440,7 @@ PanGesture::PanGesture()
   mReadPosition( 0 ),
   mInGesture( false ),
   mPredictionMode(DEFAULT_PREDICTION_MODE),
+  mPredictionAmount(DEFAULT_PREDICTION_INTERPOLATION),
   mProfiling( NULL )
 {
 }

diff --git a/dali/internal/update/gestures/scene-graph-pan-gesture.h b/dali/internal/update/gestures/scene-graph-pan-gesture.h
index 5ae28f4..a8e2170 100644 (file)
--- a/dali/internal/update/gestures/scene-graph-pan-gesture.h
+++ b/dali/internal/update/gestures/scene-graph-pan-gesture.h
@@ -256,7 +256,14 @@ public:
    *
    * @param[in] mode The prediction mode
    */
-  void SetPredictionMode(PredictionMode mode) { mPredictionMode = mode; }
+  void SetPredictionMode(PredictionMode mode);
+
+  /**
+   * @brief Sets the prediction amount of the pan gesture
+   *
+   * @param[in] amount The prediction amount, 0.0f being next vsync and each 1.0f on top is another vsync ahead, can be divisions of (0.5f)
+   */
+  void SetPredictionAmount(float amount);
 
   /**
    * Called to provide pan-gesture profiling information.
@@ -299,6 +306,7 @@ private:
   bool mInGesture;              ///< True if the gesture is currently being handled i.e. between Started <-> Finished/Cancelled
 
   PredictionMode mPredictionMode;  ///< The pan gesture prediction mode
+  float          mPredictionAmount; ///< how far into future to predict. 0.0f is next vsync since no point being less than that, adding 1.0f will predict another vsync in advance
   PanGestureProfiling* mProfiling; ///< NULL unless pan-gesture profiling information is required.
 };