dali/internal/update/gestures/scene-graph-pan-gesture.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/update/gestures/scene-graph-pan-gesture.h>
  20
  21 // EXTERNAL INCLUDES
  22
  23 // INTERNAL INCLUDES
  24 #include <dali/internal/update/gestures/pan-gesture-profiling.h>
  25
  26 namespace Dali
  27 {
  28
  29 namespace Internal
  30 {
  31
  32 namespace SceneGraph
  33 {
  34 namespace
  35 {
  36 const int MAX_GESTURE_AGE = 50; ///< maximum age of a gesture before disallowing its use in algorithm
  37 const unsigned int DEFAULT_PREDICTION_INTERPOLATION = 0; ///< how much to interpolate pan position and displacement from last vsync time
  38 } // unnamed namespace
  39
  40 const PanGesture::PredictionMode PanGesture::DEFAULT_PREDICTION_MODE = PanGesture::AVERAGE;
  41 const int PanGesture::NUM_PREDICTION_MODES = PanGesture::PREDICTION_2 + 1;
  42
  43 PanGesture* PanGesture::New()
  44 {
  45   return new PanGesture();
  46 }
  47
  48 PanGesture::~PanGesture()
  49 {
  50   delete mProfiling;
  51 }
  52
  53 void PanGesture::AddGesture( const Dali::PanGesture& gesture )
  54 {
  55   mGestures[ mWritePosition ] = gesture;
  56
  57   // Update our write position.
  58   ++mWritePosition;
  59   mWritePosition %= PAN_GESTURE_HISTORY;
  60 }
  61
  62 void PanGesture::RemoveOldHistory(PanInfoHistory& panHistory, uint currentTime, uint maxAge, uint minEvents)
  63 {
  64   PanInfoHistoryConstIter endIter = panHistory.end();
  65   PanInfoHistoryIter iter = panHistory.begin();
  66   while( iter != endIter && panHistory.size() > minEvents)
  67   {
  68     PanInfo currentGesture = *iter;
  69     if( currentTime < currentGesture.time + maxAge )
  70     {
  71       break;
  72     }
  73     iter = panHistory.erase(iter);
  74     endIter = panHistory.end();
  75   }
  76 }
  77
  78 void PanGesture::SimpleAverageAlgorithm(bool justStarted, PanInfo& gestureOut)
  79 {
  80   if( mInGesture )
  81   {
  82     if( !justStarted )
  83     {
  84       gestureOut.screen.position += mLastEventGesture.screen.position;
  85       gestureOut.local.position += mLastEventGesture.local.position;
  86       gestureOut.screen.position *= 0.5f;
  87       gestureOut.local.position *= 0.5f;
  88       // make current displacement relative to previous update-frame now.
  89       gestureOut.screen.displacement = gestureOut.screen.position - mLastEventGesture.screen.position;
  90       gestureOut.local.displacement = gestureOut.local.position - mLastEventGesture.local.position;
  91     }
  92   }
  93 }
  94
  95 void PanGesture::PredictiveAlgorithm1(int eventsThisFrame, PanInfo& gestureOut, PanInfoHistory& panHistory, unsigned int lastVSyncTime, unsigned int nextVSyncTime)
  96 {
  97   RemoveOldHistory(panHistory, lastVSyncTime, MAX_GESTURE_AGE, 0);
  98   size_t panHistorySize = panHistory.size();
  99   if( panHistorySize == 0 )
 100   {
 101     // cant do any prediction without a history
 102     return;
 103   }
 104
 105   PanInfoHistoryConstIter endIter = panHistory.end();
 106   PanInfoHistoryIter iter = panHistory.begin();
 107   Vector2 screenVelocity = gestureOut.screen.velocity;
 108   Vector2 localVelocity = gestureOut.local.velocity;
 109
 110   bool havePreviousAcceleration = false;
 111   bool previousVelocity = false;
 112   float previousAccel = 0.0f;
 113   unsigned int lastTime(0);
 114   while( iter != endIter )
 115   {
 116     PanInfo currentGesture = *iter;
 117     if( !previousVelocity )
 118     {
 119       // not yet set a previous velocity
 120       screenVelocity = currentGesture.screen.velocity;
 121       previousVelocity = true;
 122       lastTime = currentGesture.time;
 123       ++iter;
 124       continue;
 125     }
 126     float velMag = currentGesture.screen.velocity.Length();
 127     float velDiff = velMag - screenVelocity.Length();
 128     float acceleration = 0.0f;
 129     float time = (float)(currentGesture.time - lastTime);
 130     if( time > Math::MACHINE_EPSILON_1 )
 131     {
 132       acceleration = velDiff / time;
 133     }
 134     float interpolationTime = (float)((int)lastVSyncTime - (int)currentGesture.time);
 135     float newVelMag = 0.0f;
 136     if( !havePreviousAcceleration )
 137     {
 138       newVelMag =  velMag + (acceleration * interpolationTime);
 139       havePreviousAcceleration = true;
 140     }
 141     else
 142     {
 143       newVelMag = velMag + (((acceleration + previousAccel) * 0.5f) * interpolationTime);
 144     }
 145     float velMod = 1.0f;
 146     if( velMag > Math::MACHINE_EPSILON_1 )
 147     {
 148       velMod = newVelMag / velMag;
 149     }
 150     gestureOut.screen.velocity = currentGesture.screen.velocity * velMod;
 151     gestureOut.local.velocity = currentGesture.local.velocity * velMod;
 152     screenVelocity = currentGesture.screen.velocity;
 153     localVelocity = currentGesture.local.velocity;
 154     previousAccel = acceleration;
 155     ++iter;
 156   }
 157   // gestureOut's position is currently equal to the last event's position and its displacement is equal to last frame's total displacement
 158   // add interpolated distance and position to current
 159   float interpolationTime = (float)((int)lastVSyncTime - (int)gestureOut.time);
 160   // work out interpolated velocity
 161   gestureOut.screen.displacement = (gestureOut.screen.velocity * interpolationTime);
 162   gestureOut.local.displacement = (gestureOut.local.velocity * interpolationTime);
 163   gestureOut.screen.position += gestureOut.screen.displacement;
 164   gestureOut.local.position += gestureOut.local.displacement;
 165   gestureOut.time += (lastVSyncTime - gestureOut.time);
 166 }
 167
 168 void PanGesture::PredictiveAlgorithm2(int eventsThisFrame, PanInfo& gestureOut, PanInfoHistory& panHistory, unsigned int lastVSyncTime, unsigned int nextVSyncTime)
 169 {
 170   // TODO - adapt PredictiveAlgorithm1 with better smoothing, still under development
 171   RemoveOldHistory(panHistory, lastVSyncTime, MAX_GESTURE_AGE, 0);
 172   size_t panHistorySize = panHistory.size();
 173   if( panHistorySize == 0 )
 174   {
 175     // cant do any prediction without a history
 176     return;
 177   }
 178
 179   PanInfoHistoryConstIter endIter = panHistory.end();
 180   PanInfoHistoryIter iter = panHistory.begin();
 181   Vector2 screenVelocity = gestureOut.screen.velocity;
 182   Vector2 localVelocity = gestureOut.local.velocity;
 183
 184   bool havePreviousAcceleration = false;
 185   bool previousVelocity = false;
 186   float previousAccel = 0.0f;
 187   unsigned int lastTime(0);
 188   while( iter != endIter )
 189   {
 190     PanInfo currentGesture = *iter;
 191     if( !previousVelocity )
 192     {
 193       // not yet set a previous velocity
 194       screenVelocity = currentGesture.screen.velocity;
 195       previousVelocity = true;
 196       lastTime = currentGesture.time;
 197       ++iter;
 198       continue;
 199     }
 200     float previousValueWeight = (float)(MAX_GESTURE_AGE - (lastVSyncTime - lastTime)) / (float)MAX_GESTURE_AGE;
 201     float velMag = currentGesture.screen.velocity.Length();
 202     float velDiff = velMag - screenVelocity.Length();
 203     float acceleration = 0.0f;
 204     float time = (float)(currentGesture.time - lastTime);
 205     if( time > Math::MACHINE_EPSILON_1 )
 206     {
 207       acceleration = velDiff / time;
 208     }
 209     float interpolationTime = (float)((int)lastVSyncTime - (int)currentGesture.time);
 210     float newVelMag = 0.0f;
 211     if( !havePreviousAcceleration )
 212     {
 213       newVelMag =  velMag + (acceleration * interpolationTime);
 214       havePreviousAcceleration = true;
 215     }
 216     else
 217     {
 218       newVelMag = velMag + (((acceleration * (1.0f - previousValueWeight)) + (previousAccel * previousValueWeight)) * interpolationTime);
 219     }
 220     float velMod = 1.0f;
 221     if( velMag > Math::MACHINE_EPSILON_1 )
 222     {
 223       velMod = newVelMag / velMag;
 224     }
 225     gestureOut.screen.velocity = currentGesture.screen.velocity * velMod;
 226     gestureOut.local.velocity = currentGesture.local.velocity * velMod;
 227     screenVelocity = currentGesture.screen.velocity;
 228     localVelocity = currentGesture.local.velocity;
 229     previousAccel = acceleration;
 230     ++iter;
 231   }
 232   // gestureOut's position is currently equal to the last event's position and its displacement is equal to last frame's total displacement
 233   // add interpolated distance and position to current
 234   unsigned int interpolationTime = (lastVSyncTime + mPredictionAmount) - gestureOut.time;
 235   // work out interpolated velocity
 236   gestureOut.screen.displacement = (gestureOut.screen.velocity * interpolationTime);
 237   gestureOut.local.displacement = (gestureOut.local.velocity * interpolationTime);
 238   gestureOut.screen.position += gestureOut.screen.displacement;
 239   gestureOut.local.position += gestureOut.local.displacement;
 240   gestureOut.time += interpolationTime;
 241 }
 242
 243 bool PanGesture::UpdateProperties( unsigned int lastVSyncTime, unsigned int nextVSyncTime )
 244 {
 245   bool propertiesUpdated( false );
 246
 247   if( !mInGesture )
 248   {
 249     // clear current pan history
 250     mPanHistory.clear();
 251   }
 252
 253   // create an event for this frame
 254   bool justStarted ( false );
 255   bool justFinished ( false );
 256   bool eventFound( false );
 257
 258   // Not going through array from the beginning, using it as a circular buffer and only using unread
 259   // values.
 260   int eventsThisFrame = 0;
 261
 262   // create PanInfo to pass into prediction method
 263   PanInfo nextGesture = mEventGesture;
 264   // add new gestures and work out one full gesture for the frame
 265   while(mReadPosition != mWritePosition)
 266   {
 267     // Copy the gesture first
 268     PanInfo currentGesture(mGestures[mReadPosition]);
 269
 270     if( mProfiling )
 271     {
 272       mProfiling->mRawData.push_back( PanGestureProfiling::Position( currentGesture.time, currentGesture.screen.position ) );
 273     }
 274     nextGesture.local.position = currentGesture.local.position;
 275     nextGesture.local.velocity = currentGesture.local.velocity;
 276     nextGesture.screen.position = currentGesture.screen.position;
 277     nextGesture.screen.velocity = currentGesture.screen.velocity;
 278     if( !eventFound )
 279     {
 280       nextGesture.local.displacement = currentGesture.local.displacement;
 281       nextGesture.screen.displacement = currentGesture.screen.displacement;
 282     }
 283     else
 284     {
 285       nextGesture.local.displacement += currentGesture.local.displacement;
 286       nextGesture.screen.displacement += currentGesture.screen.displacement;
 287     }
 288     eventFound = true;
 289     nextGesture.time = currentGesture.time;
 290
 291     // add event to history
 292     mPanHistory.push_back(currentGesture);
 293     justStarted |= (currentGesture.state == Gesture::Started);
 294     if( currentGesture.state == Gesture::Started )
 295     {
 296       justStarted = true;
 297       // clear just finished as we have started new pan
 298       justFinished = false;
 299     }
 300     justFinished |= (currentGesture.state == Gesture::Finished || currentGesture.state == Gesture::Cancelled);
 301
 302     // Update our read position.
 303     ++eventsThisFrame;
 304     ++mReadPosition;
 305     mReadPosition %= PAN_GESTURE_HISTORY;
 306   }
 307   // set nextGesture to last gesture so it's position is correct and velocity is same as last frame
 308   mEventGesture = nextGesture;
 309
 310   mInGesture |= justStarted;
 311
 312   bool updateProperties = false;
 313
 314   if ( mInGesture )
 315   {
 316     if( mProfiling )
 317     {
 318       mProfiling->mLatestData.push_back( PanGestureProfiling::Position( lastVSyncTime, mEventGesture.screen.position ) );
 319     }
 320
 321     switch( mPredictionMode )
 322     {
 323       case NONE:
 324       {
 325         updateProperties = eventFound;
 326         break;
 327       }
 328       case AVERAGE:
 329       {
 330         SimpleAverageAlgorithm(justStarted, nextGesture);
 331         // make latest gesture equal to current gesture after averaging
 332         updateProperties = true;
 333         break;
 334       }
 335       case PREDICTION_1:
 336       {
 337         // make latest gesture equal to current gesture before interpolation
 338         PredictiveAlgorithm1(eventsThisFrame, nextGesture, mPanHistory, lastVSyncTime, nextVSyncTime);
 339         updateProperties = true;
 340         break;
 341       }
 342       case PREDICTION_2:
 343       {
 344         // make latest gesture equal to current gesture before interpolation
 345         PredictiveAlgorithm2(eventsThisFrame, nextGesture, mPanHistory, lastVSyncTime, nextVSyncTime);
 346         updateProperties = true;
 347         break;
 348       }
 349     }
 350
 351     // always keep latest gesture up to date with event gesture
 352     mLatestGesture = nextGesture;
 353
 354     if( updateProperties )
 355     {
 356       // only update properties if event received
 357       // set latest gesture to raw pan info with unchanged time
 358       mPanning.Set( mInGesture & !justFinished );
 359       mScreenPosition.Set( nextGesture.screen.position );
 360       mScreenDisplacement.Set( nextGesture.screen.displacement );
 361       mLocalPosition.Set( nextGesture.local.position );
 362       mLocalDisplacement.Set( nextGesture.local.displacement );
 363
 364       propertiesUpdated = true;
 365     }
 366
 367     if( mProfiling )
 368     {
 369       mProfiling->mAveragedData.push_back( PanGestureProfiling::Position( nextGesture.time, nextGesture.screen.position ) );
 370     }
 371   }
 372   mLastEventGesture = mEventGesture;
 373
 374   mInGesture &= ~justFinished;
 375
 376   if( mProfiling && justFinished )
 377   {
 378     mProfiling->PrintData();
 379     mProfiling->ClearData();
 380   }
 381
 382   return propertiesUpdated;
 383 }
 384
 385 const GesturePropertyBool& PanGesture::GetPanningProperty() const
 386 {
 387   return mPanning;
 388 }
 389
 390 const GesturePropertyVector2& PanGesture::GetScreenPositionProperty() const
 391 {
 392   return mScreenPosition;
 393 }
 394
 395 const GesturePropertyVector2& PanGesture::GetScreenDisplacementProperty() const
 396 {
 397   return mScreenDisplacement;
 398 }
 399
 400 const GesturePropertyVector2& PanGesture::GetLocalPositionProperty() const
 401 {
 402   return mLocalPosition;
 403 }
 404
 405 const GesturePropertyVector2& PanGesture::GetLocalDisplacementProperty() const
 406 {
 407   return mLocalDisplacement;
 408 }
 409
 410 void PanGesture::SetPredictionMode(PredictionMode mode)
 411 {
 412   mPredictionMode = mode;
 413 }
 414
 415 void PanGesture::SetPredictionAmount(unsigned int amount)
 416 {
 417   mPredictionAmount = amount;
 418 }
 419
 420 void PanGesture::EnableProfiling()
 421 {
 422   if( !mProfiling )
 423   {
 424     mProfiling = new PanGestureProfiling();
 425   }
 426 }
 427
 428 void PanGesture::ResetDefaultProperties( BufferIndex updateBufferIndex )
 429 {
 430   mScreenPosition.Reset();
 431   mScreenDisplacement.Reset();
 432   mLocalPosition.Reset();
 433   mLocalDisplacement.Reset();
 434   mPanning.Reset();
 435 }
 436
 437 PanGesture::PanGesture()
 438 : mGestures(),
 439   mWritePosition( 0 ),
 440   mReadPosition( 0 ),
 441   mInGesture( false ),
 442   mPredictionMode(DEFAULT_PREDICTION_MODE),
 443   mPredictionAmount(DEFAULT_PREDICTION_INTERPOLATION),
 444   mProfiling( NULL )
 445 {
 446 }
 447
 448 } // namespace SceneGraph
 449
 450 } // namespace Internal
 451
 452 } // namespace Dali