Add 'ExclusiveArch: armv7l' limit build to arm architecture
[platform/core/uifw/dali-toolkit.git] / base / dali-toolkit / internal / controls / scrollable / scroll-view / scroll-view-wobble-effect-impl.cpp
1 //
2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
3 //
4 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
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 #include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-effect-impl.h>
18 #include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-wobble-effect-impl.h>
19 #include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-impl.h>
20
21 using namespace Dali;
22
23 namespace // unnamed namespace
24 {
25
26 const float WOBBLEEFFECT_FRICTION_COEFFICIENT = 0.8f;     ///< (deacc) - velocity multiplier per unit time (80%)
27 const float WOBBLEEFFECT_IMPULSE_DISTANCE_FACTOR = 0.1f;  ///< (acc) - move by 10% of distance-delta per unit time
28 const float WOBBLEEFFECT_TIME_FACTOR = 30.0f;             ///< (T) - 30 times faster (unit time = 1/30th sec)
29 const float WOBBLEEFFECT_ANIMATION_MAX_TIME = 60.0f;      ///< Animation time (every time finishes, checks if it needs to go again)
30 const float WOBBLEEFFECT_STABLE_TIME_THRESHOLD = 0.5f;    ///< Must be stable for more than half a second to stop animating.
31 const float STABILITY_DELTA_THRESHOLD = Math::MACHINE_EPSILON_10000;  ///< When velocity delta is greater than this threshold it is considered in motion.
32
33 /**
34  * Gets a property index. If the property doesn't already exist, then
35  * it will create the property.
36  * @param[in] handle The handle that owns or will own the property
37  * @param[in] name The name for this property
38  * @param[in] propertyValue The initial value for this property
39  * @return The property index for this property is returned.
40  */
41 Property::Index SafeRegisterProperty( Handle& handle, const std::string& name, Property::Value propertyValue )
42 {
43   Property::Index index = handle.GetPropertyIndex( name );
44
45   if(index == Property::INVALID_INDEX)
46   {
47     index = handle.RegisterProperty( name, propertyValue );
48   }
49
50   return index;
51 }
52
53 } // unnamed namespace
54
55 namespace Dali
56 {
57
58 namespace Toolkit
59 {
60
61 namespace Internal
62 {
63
64 /**
65  * ScrollView WobbleEffect constraint
66  * This constraint has a chase position and velocity, that chases
67  * a target position (scroll-position + scroll-offset). As it has a
68  * velocity. It will eventually pass it's target position, and chase back
69  * in the opposite direction. As it has a friction coefficient, it will
70  * gradually slow, and reach it's target position (stabilized).
71  */
72 struct ScrollViewWobbleEffectConstraint
73 {
74   /**
75    * @param[in,out] wobbleEffect Reference to wobbleEffect instance
76    */
77   ScrollViewWobbleEffectConstraint(ScrollViewWobbleEffect& wobbleEffect)
78   : mChase(Vector3::ZERO),
79     mVelocity(Vector3::ZERO),
80     mTime(0.0f),
81     mStabilityTimeCounter(0),
82     mStabilized(true),
83     mWobbleEffect(wobbleEffect),
84     mAnimationCycleId(0)
85   {
86
87   }
88
89   /**
90    * @param[out] current The new wobble value
91    * @param[in] propertyTime The current time since the wobble effect started
92    * @param[in] propertyPosition The scroll-position
93    * @param[in] propertyOffset The scroll-overshoot
94    */
95   Vector3 operator()(const Vector3& current,
96                     const PropertyInput& propertyTime,
97                     const PropertyInput& propertyPosition,
98                     const PropertyInput& propertyOffsetX,
99                     const PropertyInput& propertyOffsetY)
100   {
101     Vector3 dir;
102
103     if(mStabilized)
104     {
105       // check if animation cycle id has changed (if so then this spells
106       // the start of a new animation)
107       if(mAnimationCycleId != mWobbleEffect.GetAnimationCycleId())
108       {
109         mStabilized = false;
110       }
111     }
112     else
113     {
114       // not stable (i.e. wobbling)
115       Vector3 offset(propertyOffsetX.GetFloat(), propertyOffsetY.GetFloat(), 0.0f);
116       const Vector3& position = propertyPosition.GetVector3() - offset;
117       const float time = propertyTime.GetFloat();
118       const float timePassed = time - mTime;
119
120       mTime = time;
121
122       if(timePassed>0)
123       {
124         const Vector3 delta = position - mChase;
125
126         // Check to see if wobble has stabilized.
127         if( (fabsf(delta.x) < STABILITY_DELTA_THRESHOLD) &&
128             (fabsf(mVelocity.x) < STABILITY_DELTA_THRESHOLD) )
129         {
130           mStabilityTimeCounter+=timePassed;
131
132           if(mStabilityTimeCounter > WOBBLEEFFECT_STABLE_TIME_THRESHOLD)
133           {
134             mStabilityTimeCounter = 0.0f;
135             mStabilized = true;
136             mWobbleEffect.IncrementStableCount();
137             mAnimationCycleId = mWobbleEffect.GetAnimationCycleId();
138           }
139         }
140         else
141         {
142           mStabilityTimeCounter = 0.0f;
143         }
144
145         if(!mStabilized)
146         {
147           float t = timePassed * WOBBLEEFFECT_TIME_FACTOR;
148
149           mVelocity *= pow( WOBBLEEFFECT_FRICTION_COEFFICIENT, t );
150           mVelocity += delta * 0.1f * t;
151           mChase += mVelocity;
152         }
153         else
154         {
155           // stabilized, so chase should be exactly on position.
156           mChase = position;
157         }
158       }
159
160       dir.x = propertyPosition.GetVector3().x - mChase.x;
161       dir.y = propertyPosition.GetVector3().y - mChase.y;
162     } // end else
163
164     return dir;
165   }
166
167   Vector3 mChase;                                 ///< Chaser position
168   Vector3 mVelocity;                              ///< Velocity of Chaser
169   float mTime;                                    ///< Current time.
170   float mStabilityTimeCounter;                    ///< Time in seconds that stable for.
171   bool mStabilized;                               ///< Stabilized flag.
172   ScrollViewWobbleEffect& mWobbleEffect;          ///< Reference to Wobble Effect
173   unsigned int mAnimationCycleId;                 ///< Animation Cycle Id
174 };
175
176 ScrollViewWobbleEffect::ScrollViewWobbleEffect()
177 : mPropertyTime(Property::INVALID_INDEX)
178 {
179
180 }
181
182 ScrollViewWobbleEffect::~ScrollViewWobbleEffect()
183 {
184 }
185
186 void ScrollViewWobbleEffect::IncrementStableCount()
187 {
188   mStableCurrent++;
189 }
190
191 unsigned int ScrollViewWobbleEffect::GetAnimationCycleId() const
192 {
193   return mAnimationCycleId;
194 }
195
196 void ScrollViewWobbleEffect::OnAttach(Toolkit::ScrollView& scrollView)
197 {
198   mStableCurrent = 0;
199   mAnimationCycleId = 0;
200
201   // Create effect-time property if not already created.
202   if(mPropertyTime == Property::INVALID_INDEX)
203   {
204     mPropertyTime = SafeRegisterProperty( scrollView, Toolkit::ScrollViewWobbleEffect::EFFECT_TIME, 0.0f );
205   }
206
207   // Connect to the scroll view signals
208   scrollView.ScrollStartedSignal().Connect(this, &ScrollViewWobbleEffect::OnScrollStart);
209   scrollView.ScrollUpdatedSignal().Connect(this, &ScrollViewWobbleEffect::OnScrollUpdate);
210   scrollView.ScrollCompletedSignal().Connect(this, &ScrollViewWobbleEffect::OnScrollComplete);
211
212   AttachActor(scrollView);
213 }
214
215 void ScrollViewWobbleEffect::OnDetach(Toolkit::ScrollView& scrollView)
216 {
217   scrollView.ScrollStartedSignal().Disconnect(this, &ScrollViewWobbleEffect::OnScrollStart);
218   scrollView.ScrollUpdatedSignal().Disconnect(this, &ScrollViewWobbleEffect::OnScrollUpdate);
219   scrollView.ScrollCompletedSignal().Disconnect(this, &ScrollViewWobbleEffect::OnScrollComplete);
220
221   if(mAnimation)
222   {
223     mAnimation.FinishedSignal().Disconnect(this, &ScrollViewWobbleEffect::OnAnimationFinished);
224     mAnimation.Clear();
225     mAnimation.Reset();
226   }
227 }
228
229 void ScrollViewWobbleEffect::AttachActor(Actor actor)
230 {
231   Property::Index propertyPosition = actor.GetPropertyIndex(Toolkit::ScrollView::SCROLL_POSITION_PROPERTY_NAME);
232   Property::Index propertyOvershootX = actor.GetPropertyIndex(Toolkit::ScrollView::SCROLL_OVERSHOOT_X_PROPERTY_NAME);
233   Property::Index propertyOvershootY = actor.GetPropertyIndex(Toolkit::ScrollView::SCROLL_OVERSHOOT_Y_PROPERTY_NAME);
234
235   // Create effect-overshoot property if not already created.
236   Property::Index propertyEffectOvershoot = actor.GetPropertyIndex(Toolkit::ScrollViewWobbleEffect::EFFECT_OVERSHOOT);
237   if(propertyEffectOvershoot == Property::INVALID_INDEX)
238   {
239     propertyEffectOvershoot = actor.RegisterProperty(Toolkit::ScrollViewWobbleEffect::EFFECT_OVERSHOOT, Vector3::ZERO);
240   }
241
242   Actor scrollView = GetScrollView();
243
244   Constraint constraint = Constraint::New<Vector3>( propertyEffectOvershoot,
245                                                     Source(scrollView, mPropertyTime),
246                                                     Source(actor, propertyPosition),
247                                                     Source(actor, propertyOvershootX),
248                                                     Source(actor, propertyOvershootY),
249                                                     ScrollViewWobbleEffectConstraint(*this) );
250   actor.ApplyConstraint(constraint);
251 }
252
253 void ScrollViewWobbleEffect::DetachActor(Actor actor)
254 {
255   // TODO: remove the specific constraint defined in AttachActor (and possibly
256   // unregister property) - neither functionality exists in Dali.
257 }
258
259 void ScrollViewWobbleEffect::ContinueAnimation(float endTime)
260 {
261
262   // continue animating
263   if(mAnimation)
264   {
265     mAnimation.FinishedSignal().Disconnect(this, &ScrollViewWobbleEffect::OnAnimationFinished);
266     mAnimation.Clear();
267   }
268
269   Actor scrollView = GetScrollView();
270
271   mAnimation = Animation::New(WOBBLEEFFECT_ANIMATION_MAX_TIME);
272   mAnimation.AnimateTo( Property(scrollView, mPropertyTime), endTime, AlphaFunctions::Linear );
273   mAnimation.FinishedSignal().Connect(this, &ScrollViewWobbleEffect::OnAnimationFinished);
274   mAnimation.Play();
275
276 }
277
278 void ScrollViewWobbleEffect::OnScrollStart( const Vector3& position )
279 {
280   // When animation starts, all constraints all unstable,
281   // and we change the animation cycle id.
282   mStableCurrent = 0;
283   mAnimationCycleId++;
284
285   GetScrollView().SetProperty(mPropertyTime, 0.0f);
286
287   ContinueAnimation(WOBBLEEFFECT_ANIMATION_MAX_TIME);
288 }
289
290 void ScrollViewWobbleEffect::OnScrollUpdate( const Vector3& position )
291 {
292   // nothing to do
293 }
294
295 void ScrollViewWobbleEffect::OnScrollComplete( const Vector3& position )
296 {
297   // nothing to do
298 }
299
300 void ScrollViewWobbleEffect::OnAnimationFinished( Animation& animation )
301 {
302   if(mStableCurrent!=1)
303   {
304     // still unstable, so continue animating.
305     float endTime = GetScrollView().GetProperty<float>(mPropertyTime) + WOBBLEEFFECT_ANIMATION_MAX_TIME;
306     ContinueAnimation(endTime);
307   }
308 }
309
310 } // namespace Internal
311
312 } // namespace Toolkit
313
314 } // namespace Dali