Add 'ExclusiveArch: armv7l' limit build to arm architecture
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / scrollable / scroll-view / scroll-view-page-spiral-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 // CLASS HEADER
18 #include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-page-spiral-effect-impl.h>
19
20 // EXTERNAL INCLUDES
21 #include <boost/bind.hpp>
22
23 // INTERNAL INCLUDES
24 #include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-helper-functions.h>
25 #include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-impl.h>
26
27 namespace Dali
28 {
29
30 namespace Toolkit
31 {
32
33 namespace Internal
34 {
35
36 namespace // unnamed namespace
37 {
38
39 const float PAGE_EPSILON_FACTOR( 0.25f );
40
41 const float PAGE_SIZE_RELATIVE_ANGLE_FACTOR( 0.75f );
42 const float NON_SCROLL_PAGE_SPIRAL_ANGLE_FACTOR( 1.5f );
43
44 const float SCROLL_PAGE_OPAQUE_BEFORE( 0.4f );
45 const float SCROLL_PAGE_FULLY_TRANSPARENT_AFTER( 0.9f );
46 const float NON_SCROLL_PAGE_OPAQUE_BEFORE( 0.8f );
47 const float NON_SCROLL_PAGE_FULLY_TRANSPARENT_AFTER( 1.0f );
48
49 const float RADIUS_FACTOR( 0.95f );
50 const float SCROLL_PAGE_Z_POSITION_FACTOR( -2.0f );
51 const float NON_SCROLL_PAGE_Z_POSITION_FACTOR( -0.75f );
52
53 using namespace ScrollViewHelperFunctions;
54
55 /**
56  * ScrollPageSpiralEffectInfo
57  *
58  * Rotate constraint: adjusts the angle of the page based on its position relative to the middle of
59  * the screen.
60  * When at middle of screen Angles on X and Y Axes is 0.
61  *
62  * Color constraint: adjusts the alpha of the page based on their parent page's position relative
63  * to the middle of the screen.
64  * When at middle of screen Alpha is 100% opacity.
65  * When outside the viewable area, the opacity is 0%.
66  *
67  * Position constraint: adjusts the position of the page based on their parent page's position
68  * relative to the middle of the screen.
69  * When at middle of the screen the position is not altered.
70  */
71 class ScrollPageSpiralEffectInfo : public Dali::RefObject
72 {
73 public:
74
75   ScrollPageSpiralEffectInfo( const Vector2& spiralAngle, bool scrollWrap )
76   : mSpiralAngle( spiralAngle ),
77     mScrollWrap( scrollWrap )
78   {
79   }
80
81   /**
82    * @param[in] current The current orientation of this Actor
83    * @param[in] pagePositionProperty The page's position.
84    * @param[in] scrollPositionProperty The scroll-view's position property (SCROLL_POSITION_PROPERTY_NAME)
85    * @param[in] scrollPositionMin The minimum extent of this scroll domain. (SCROLL_POSITION_MIN_PROPERTY_NAME)
86    * @param[in] scrollPositionMax The maximum extent of this scroll domain. (SCROLL_POSITION_MIN_PROPERTY_NAME)
87    * @param[in] pageSizeProperty The size of the page. (scrollView SIZE)
88    * @param[in] scrollPageStartPositionProperty The position of the page where scrolling started. (SCROLL_START_PAGE_POSITION_PROPERTY_NAME)
89    * @return The new orientation of this Actor.
90    */
91   Quaternion RotationConstraint(const Quaternion& current,
92                                 const PropertyInput& pagePositionProperty,
93                                 const PropertyInput& scrollPositionProperty,
94                                 const PropertyInput& scrollPositionMin,
95                                 const PropertyInput& scrollPositionMax,
96                                 const PropertyInput& pageSizeProperty,
97                                 const PropertyInput& scrollStartPagePositionProperty)
98   {
99     const Vector3& pagePosition = pagePositionProperty.GetVector3();
100     const Vector3& scrollPosition = scrollPositionProperty.GetVector3();
101     const Vector3& scrollStartPagePosition = scrollStartPagePositionProperty.GetVector3();
102
103     // Get position of page.
104     Vector3 position = pagePosition + scrollPosition;
105
106     // short circuit: if we're looking straight on at the page.
107     if( IsStraightOnView( position ) )
108     {
109       return current;
110     }
111
112     const Vector3& pageSize = pageSizeProperty.GetVector3();
113     const Vector3& minScrollPosition( scrollPositionMin.GetVector3() );
114     const Vector3& maxScrollPosition( scrollPositionMax.GetVector3() );
115
116     if( mScrollWrap )
117     {
118       WrapPositionWithinDomain( position, pageSize, minScrollPosition, maxScrollPosition );
119     }
120
121     // short circuit: for pages outside of view.
122     if( IsOutsideView( position, pageSize ) )
123     {
124       return current;
125     }
126
127     Vector2 angle( position / ( pageSize * PAGE_SIZE_RELATIVE_ANGLE_FACTOR ) * Vector3( mSpiralAngle ) );
128     const Vector2 epsilon( pageSize * PAGE_EPSILON_FACTOR );
129     Vector2 distanceFromScrollPage;
130     distanceFromScrollPage.x = ShortestDistanceInDomain( scrollStartPagePosition.x, pagePosition.x, minScrollPosition.x, maxScrollPosition.x );
131     distanceFromScrollPage.y = ShortestDistanceInDomain( scrollStartPagePosition.y, pagePosition.y, minScrollPosition.y, maxScrollPosition.y );
132
133     Vector2 angleMaxMin( mSpiralAngle );
134
135     // X rotation
136     if ( fabsf( distanceFromScrollPage.x ) <= epsilon.x ) // Did scroll start on this page?
137     {
138       angle.x = -angle.x * 0.9f;
139     }
140     else
141     {
142       // If not then multiply by angle factor.
143       angleMaxMin.x *= NON_SCROLL_PAGE_SPIRAL_ANGLE_FACTOR;
144     }
145     ClampInPlace( angle.x, -angleMaxMin.x, angleMaxMin.x );
146
147     // Y rotation
148     if ( fabsf( distanceFromScrollPage.y ) > epsilon.y ) // If not on the scroll page then multiply by angle factor.
149     {
150       angleMaxMin.y *= NON_SCROLL_PAGE_SPIRAL_ANGLE_FACTOR;
151       angle.y = -angle.y;
152     }
153     ClampInPlace( angle.y, -angleMaxMin.y, angleMaxMin.y );
154
155     Quaternion rotation = Quaternion( angle.x, Vector3::YAXIS ) *
156                           Quaternion( angle.y, Vector3::XAXIS ) *
157                           current;
158
159     return rotation;
160   }
161
162   /**
163    * @param[in] current The current color of this Actor
164    * @param[in] pagePositionProperty The page's position.
165    * @param[in] scrollPositionProperty The scroll-view's position property (SCROLL_POSITION_PROPERTY_NAME)
166    * @param[in] scrollPositionMin The minimum extent of this scroll domain. (SCROLL_POSITION_MIN_PROPERTY_NAME)
167    * @param[in] scrollPositionMax The maximum extent of this scroll domain. (SCROLL_POSITION_MIN_PROPERTY_NAME)
168    * @param[in] pageSizeProperty The size of the page. (scrollView SIZE)
169    * @param[in] scrollPageStartPositionProperty The position of the page where scrolling started. (SCROLL_START_PAGE_POSITION_PROPERTY_NAME)
170    * @return The new color of this Actor.
171    */
172   Vector4 ColorConstraint(const Vector4& current,
173                           const PropertyInput& pagePositionProperty,
174                           const PropertyInput& scrollPositionProperty,
175                           const PropertyInput& scrollPositionMin,
176                           const PropertyInput& scrollPositionMax,
177                           const PropertyInput& pageSizeProperty,
178                           const PropertyInput& scrollStartPagePositionProperty)
179   {
180     const Vector3& pagePosition = pagePositionProperty.GetVector3();
181     const Vector3& scrollPosition = scrollPositionProperty.GetVector3();
182     const Vector3& scrollStartPagePosition = scrollStartPagePositionProperty.GetVector3();
183
184     // Get position of page.
185     Vector3 position = pagePosition + scrollPosition;
186
187     // short circuit: if we're looking straight on at the page.
188     if( IsStraightOnView( position ) )
189     {
190       return current;
191     }
192
193     const Vector3& pageSize = pageSizeProperty.GetVector3();
194     const Vector3& minScrollPosition( scrollPositionMin.GetVector3() );
195     const Vector3& maxScrollPosition( scrollPositionMax.GetVector3() );
196
197     if( mScrollWrap )
198     {
199       WrapPositionWithinDomain( position, pageSize, minScrollPosition, maxScrollPosition );
200     }
201
202     // short circuit: for pages outside of view.
203     if( IsOutsideView( position, pageSize ) )
204     {
205       // note preserve color channels incase there is a shader/further constraint
206       // that wishes to do something with that information.
207       return Vector4(current.r, current.g, current.b, 0.0f);
208     }
209
210     Vector4 color( current );
211     Vector2 distance( position / pageSize );
212     float distanceLength( distance.Length() );
213     const Vector2 epsilon( pageSize * PAGE_EPSILON_FACTOR );
214     Vector2 distanceFromScrollPage;
215     distanceFromScrollPage.x = ShortestDistanceInDomain( scrollStartPagePosition.x, pagePosition.x, minScrollPosition.x, maxScrollPosition.x );
216     distanceFromScrollPage.y = ShortestDistanceInDomain( scrollStartPagePosition.y, pagePosition.y, minScrollPosition.y, maxScrollPosition.y );
217
218     float fullyOpaqueBefore( 0.0f );
219     float fullyTransparentAfter( 1.0f );
220
221     if ( ( fabsf( distanceFromScrollPage.x ) <= epsilon.x ) && ( fabsf( distanceFromScrollPage.y ) <= epsilon.y )) // Did scroll start on this page?
222     {
223       fullyOpaqueBefore = SCROLL_PAGE_OPAQUE_BEFORE;
224       fullyTransparentAfter = SCROLL_PAGE_FULLY_TRANSPARENT_AFTER;
225     }
226     else
227     {
228       fullyOpaqueBefore = NON_SCROLL_PAGE_OPAQUE_BEFORE;
229       fullyTransparentAfter = NON_SCROLL_PAGE_FULLY_TRANSPARENT_AFTER;
230     }
231
232     if ( distanceLength <= fullyOpaqueBefore )
233     {
234       color.a = 1.0f;
235     }
236     else if ( distanceLength <= fullyTransparentAfter )
237     {
238       float opacity( distanceLength - fullyOpaqueBefore );
239       opacity /= fullyTransparentAfter - fullyOpaqueBefore;
240       color.a = Clamp( 1.0f - opacity, 0.0f, 1.0f );
241     }
242     else
243     {
244       color.a = 0.0f;
245     }
246
247     return color;
248   }
249
250   /**
251    * @param[in] current The current position
252    * @param[in] pagePositionProperty The page's position.
253    * @param[in] scrollPositionProperty The scroll-view's position property (SCROLL_POSITION_PROPERTY_NAME)
254    * @param[in] scrollPositionMin The minimum extent of this scroll domain. (SCROLL_POSITION_MIN_PROPERTY_NAME)
255    * @param[in] scrollPositionMax The maximum extent of this scroll domain. (SCROLL_POSITION_MIN_PROPERTY_NAME)
256    * @param[in] pageSizeProperty The size of the page. (scrollView SIZE)
257    * @param[in] scrollPageStartPositionProperty The position of the page where scrolling started. (SCROLL_START_PAGE_POSITION_PROPERTY_NAME)
258    * @return The new position of this Actor.
259    */
260   Vector3 PositionConstraint(const Vector3& current,
261                              const PropertyInput& pagePositionProperty,
262                              const PropertyInput& scrollPositionProperty,
263                              const PropertyInput& scrollPositionMin,
264                              const PropertyInput& scrollPositionMax,
265                              const PropertyInput& pageSizeProperty,
266                              const PropertyInput& scrollStartPagePositionProperty)
267   {
268     const Vector3& pagePosition = pagePositionProperty.GetVector3();
269     const Vector3& scrollPosition = scrollPositionProperty.GetVector3();
270     const Vector3& scrollStartPagePosition = scrollStartPagePositionProperty.GetVector3();
271
272     // Get position of page.
273     Vector3 position = pagePosition + scrollPosition;
274
275     // short circuit: if we're looking straight on at the page.
276     if( IsStraightOnView( position ) )
277     {
278       return current + scrollPosition;
279     }
280
281     const Vector3& pageSize = pageSizeProperty.GetVector3();
282     const Vector3& minScrollPosition( scrollPositionMin.GetVector3() );
283     const Vector3& maxScrollPosition( scrollPositionMax.GetVector3() );
284
285     if( mScrollWrap )
286     {
287       WrapPositionWithinDomain( position, pageSize, minScrollPosition, maxScrollPosition );
288     }
289
290     // short circuit: for pages outside of view.
291     if( IsOutsideView( position, pageSize ) )
292     {
293       // position actors at: scrollposition (Property) + pagePosition (Parent) + current (this)
294       // they will be invisible so doesn't have to be precise, just away from stage.
295       return current + scrollPosition;
296     }
297
298     const Vector2 angle( position / pageSize * ( Dali::Math::PI_4 ) );
299     const Vector2 radius( pageSize * RADIUS_FACTOR );
300     const Vector2 epsilon( pageSize * PAGE_EPSILON_FACTOR  );
301     Vector2 distanceFromScrollPage;
302     distanceFromScrollPage.x = ShortestDistanceInDomain( scrollStartPagePosition.x, pagePosition.x, minScrollPosition.x, maxScrollPosition.x );
303     distanceFromScrollPage.y = ShortestDistanceInDomain( scrollStartPagePosition.y, pagePosition.y, minScrollPosition.y, maxScrollPosition.y );
304
305     // X position and relative Z position
306     if ( fabsf( distanceFromScrollPage.x ) <= epsilon.x ) // Did scroll start on this page?
307     {
308       position.x = radius.x * sin( angle.x ) * 0.77f;
309       position.z = fabsf( position.x ) * SCROLL_PAGE_Z_POSITION_FACTOR;
310     }
311     else
312     {
313       position.x = radius.x * ( sinf( angle.x * Math::PI * 0.4f ) );
314
315       position.z = fabsf( position.x ) * NON_SCROLL_PAGE_Z_POSITION_FACTOR;
316     }
317
318     // Y position and relative Z position
319     if ( fabsf( distanceFromScrollPage.y ) <= epsilon.y ) // Did scroll start on this page?
320     {
321       position.y = radius.y * sin( angle.y ) * 0.77f;
322       position.z += fabsf( position.y ) * SCROLL_PAGE_Z_POSITION_FACTOR;
323     }
324     else
325     {
326       position.y = radius.y * ( sinf( angle.y * Math::PI * 0.4f ) );
327
328       position.z += fabsf( position.y ) * NON_SCROLL_PAGE_Z_POSITION_FACTOR;
329     }
330
331     return position;
332   }
333
334   Vector2 mSpiralAngle; ///< The angle of the spirald page
335   bool mScrollWrap;      ///< Whether the scroll view wraps or not.
336 };
337
338 typedef IntrusivePtr<ScrollPageSpiralEffectInfo> ScrollPageSpiralEffectInfoPtr;
339
340 /**
341  * Helper: Applies the 3D scroll cube constraints to the child actor
342  *
343  * @param[in] scrollView The ScrollView containing the pages.
344  * @param[in] child The child to be affected with the 3D Effect.
345  * @param[in] info The effect info for the constraints
346  */
347 void ApplyScrollCubeConstraints(Toolkit::ScrollView scrollView,
348                                 Actor child,
349                                 ScrollPageSpiralEffectInfoPtr info)
350 {
351   // Apply constraints to this actor //
352   Constraint constraint;
353   constraint = Constraint::New<Quaternion>( Actor::ROTATION,
354                                             LocalSource(Actor::POSITION),
355                                             Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_FINAL_PROPERTY_NAME ) ),
356                                             Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_POSITION_MIN_PROPERTY_NAME ) ),
357                                             Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_POSITION_MAX_PROPERTY_NAME ) ),
358                                             Source(scrollView, Actor::SIZE ),
359                                             Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_START_PAGE_POSITION_PROPERTY_NAME ) ),
360                                             boost::bind( &ScrollPageSpiralEffectInfo::RotationConstraint, info, _1, _2, _3, _4, _5, _6, _7) );
361
362   constraint.SetRemoveAction( Constraint::Discard );
363   child.ApplyConstraint( constraint );
364
365   constraint = Constraint::New<Vector4>( Actor::COLOR,
366                                          LocalSource(Actor::POSITION),
367                                          Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_FINAL_PROPERTY_NAME ) ),
368                                          Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_POSITION_MIN_PROPERTY_NAME ) ),
369                                          Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_POSITION_MAX_PROPERTY_NAME ) ),
370                                          Source(scrollView, Actor::SIZE ),
371                                          Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_START_PAGE_POSITION_PROPERTY_NAME ) ),
372                                          boost::bind( &ScrollPageSpiralEffectInfo::ColorConstraint, info, _1, _2, _3, _4, _5, _6, _7) );
373
374   constraint.SetRemoveAction( Constraint::Discard );
375   child.ApplyConstraint( constraint );
376
377   constraint = Constraint::New<Vector3>( Actor::POSITION,
378                                          LocalSource(Actor::POSITION),
379                                          Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_FINAL_PROPERTY_NAME ) ),
380                                          Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_POSITION_MIN_PROPERTY_NAME ) ),
381                                          Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_POSITION_MAX_PROPERTY_NAME ) ),
382                                          Source(scrollView, Actor::SIZE ),
383                                          Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_START_PAGE_POSITION_PROPERTY_NAME ) ),
384                                          boost::bind( &ScrollPageSpiralEffectInfo::PositionConstraint, info, _1, _2, _3, _4, _5, _6, _7) );
385
386   constraint.SetRemoveAction( Constraint::Discard );
387   child.ApplyConstraint( constraint );
388 }
389
390 } // unnamed namespace
391
392 ScrollViewPageSpiralEffect::ScrollViewPageSpiralEffect()
393 {
394
395 }
396
397 ScrollViewPageSpiralEffect::~ScrollViewPageSpiralEffect()
398 {
399 }
400
401 void ScrollViewPageSpiralEffect::ApplyToPage( Actor page, const Vector2& spiralAngle )
402 {
403   Toolkit::ScrollView scrollView( GetScrollView() );
404
405   if ( scrollView )
406   {
407     ScrollPageSpiralEffectInfoPtr info(new ScrollPageSpiralEffectInfo( spiralAngle, GetImpl( scrollView ).GetWrapMode() ));
408     ApplyScrollCubeConstraints( scrollView, page, info );
409   }
410 }
411
412 void ScrollViewPageSpiralEffect::OnAttach(Toolkit::ScrollView& scrollView)
413 {
414 }
415
416 void ScrollViewPageSpiralEffect::OnDetach(Toolkit::ScrollView& scrollView)
417 {
418 }
419
420 } // namespace Internal
421
422 } // namespace Toolkit
423
424 } // namespace Dali